@c-rex/templates 0.0.8 → 0.0.9

package/dist/home/layout.esm.js

@@ -0,0 +1,827 @@
+// ../core/src/requests.ts
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import axios from "axios";
+// ../constants/src/index.ts
+var API = {
+    MAX_RETRY: 3,
+    API_TIMEOUT: 1e4,
+    API_HEADERS: {
+        "content-Type": "application/json"
+    }
+};
+// ../core/src/requests.ts
+var CrexApi = /*#__PURE__*/ function() {
+    "use strict";
+    function CrexApi(baseUrl, logger) {
+        _class_call_check(this, CrexApi);
+        this.apiClient = axios.create({
+            baseURL: baseUrl,
+            headers: {
+                "content-Type": "application/json"
+            }
+        });
+        this.logger = logger;
+    }
+    _create_class(CrexApi, [
+        {
+            key: "execute",
+            value: function execute(_0) {
+                return /*#__PURE__*/ _async_to_generator(function(param) {
+                    var url, method, params, body, headers, response, retry, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                url = param.url, method = param.method, params = param.params, body = param.body, headers = param.headers;
+                                response = void 0;
+                                retry = 0;
+                                _state.label = 1;
+                            case 1:
+                                if (!(retry < API.MAX_RETRY)) return [
+                                    3,
+                                    6
+                                ];
+                                _state.label = 2;
+                            case 2:
+                                _state.trys.push([
+                                    2,
+                                    4,
+                                    ,
+                                    5
+                                ]);
+                                return [
+                                    4,
+                                    this.apiClient.request({
+                                        url: url,
+                                        method: method,
+                                        data: body,
+                                        params: params,
+                                        headers: headers
+                                    })
+                                ];
+                            case 3:
+                                response = _state.sent();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 4:
+                                error = _state.sent();
+                                this.logger.log("error", "API.execute error when request ".concat(url, ". Error: ").concat(error));
+                                throw error;
+                            case 5:
+                                retry++;
+                                return [
+                                    3,
+                                    1
+                                ];
+                            case 6:
+                                if (response) {
+                                    return [
+                                        2,
+                                        response.data
+                                    ];
+                                }
+                                throw new Error("API.execute error: Failed to retrieve a valid response");
+                        }
+                    });
+                }).apply(this, arguments);
+            }
+        }
+    ]);
+    return CrexApi;
+}();
+// ../core/src/cookies.ts
+var GLOBAL_KEY = "__CREX_INITIAL_CONFIG__";
+var CONFIG_COOKIE_KEY = "crex_config";
+function isBrowser() {
+    return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function parseCookies() {
+    var cookies = {};
+    if (typeof document === "undefined") {
+        return cookies;
+    }
+    document.cookie.split(";").forEach(function(cookie) {
+        var _cookie_split = _sliced_to_array(cookie.split("="), 2), key = _cookie_split[0], value = _cookie_split[1];
+        if (key && value) {
+            cookies[key.trim()] = decodeURIComponent(value.trim());
+        }
+    });
+    return cookies;
+}
+function setCookie(name, value) {
+    var days = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 30;
+    if (typeof document === "undefined") return;
+    var expires = new Date(Date.now() + days * 86400 * 1e3).toUTCString();
+    document.cookie = "".concat(name, "=").concat(encodeURIComponent(value), "; path=/; expires=").concat(expires, "; SameSite=Lax");
+}
+function setConfig(config) {
+    if (isBrowser()) {
+        setCookie(CONFIG_COOKIE_KEY, JSON.stringify(config));
+    } else {
+        if (typeof global !== "undefined" && !(GLOBAL_KEY in global)) {
+            global[GLOBAL_KEY] = null;
+        }
+        var globalConfig = global[GLOBAL_KEY];
+        if (globalConfig === null) {
+            global[GLOBAL_KEY] = config;
+        }
+    }
+}
+function getConfig() {
+    var returnValue;
+    if (isBrowser()) {
+        var cookies = parseCookies();
+        var configStr = cookies[CONFIG_COOKIE_KEY];
+        if (configStr) {
+            try {
+                return JSON.parse(configStr);
+            } catch (e) {
+                return null;
+            }
+        }
+        return null;
+    } else {
+        returnValue = global[GLOBAL_KEY];
+    }
+    return returnValue;
+}
+// ../core/src/sdk.ts
+var CrexSDK = /*#__PURE__*/ function() {
+    "use strict";
+    function CrexSDK() {
+        _class_call_check(this, CrexSDK);
+        var config = getConfig();
+        this.customerConfig = config;
+        this.api = new CrexApi(this.customerConfig.baseUrl, null);
+    }
+    _create_class(CrexSDK, null, [
+        {
+            key: "setConfig",
+            value: function setConfig1(config) {
+                setConfig(config);
+            }
+        }
+    ]);
+    return CrexSDK;
+}();
+// ../utils/src/utils.ts
+var createParams = function(fieldsList) {
+    var key = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "Fields";
+    return fieldsList.map(function(item) {
+        return {
+            key: key,
+            value: item
+        };
+    });
+};
+var updateUrlWithParams = function(router, params) {
+    var searchParams = new URLSearchParams(window.location.search);
+    params.forEach(function(param) {
+        searchParams.set(param.key, param.value.toString());
+    });
+    var queryString = searchParams.toString();
+    router.push("".concat(window.location.pathname, "?").concat(queryString));
+};
+var generateQueryParams = function(params) {
+    var queryParams = params.map(function(param) {
+        return "".concat(encodeURIComponent(param.key), "=").concat(encodeURIComponent(param.value));
+    }).join("&");
+    return queryParams;
+};
+// ../utils/src/classMerge.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+// ../services/src/baseService.ts
+var BaseService = /*#__PURE__*/ function() {
+    "use strict";
+    function BaseService(endpoint) {
+        _class_call_check(this, BaseService);
+        this.SDK = new CrexSDK();
+        this.api = this.SDK.api;
+        this.endpoint = endpoint;
+    }
+    _create_class(BaseService, [
+        {
+            key: "request",
+            value: function request(_0) {
+                return /*#__PURE__*/ _async_to_generator(function(param) {
+                    var _param_path, path, _param_method, method, _param_params, params, _param_headers, headers, _param_transformer, transformer, url, queryParams, response, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _param_path = param.path, path = _param_path === void 0 ? "" : _param_path, _param_method = param.method, method = _param_method === void 0 ? "get" : _param_method, _param_params = param.params, params = _param_params === void 0 ? [] : _param_params, _param_headers = param.headers, headers = _param_headers === void 0 ? {} : _param_headers, _param_transformer = param.transformer, transformer = _param_transformer === void 0 ? function(response) {
+                                    return response;
+                                } : _param_transformer;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    4,
+                                    ,
+                                    5
+                                ]);
+                                url = "".concat(this.endpoint).concat(path);
+                                queryParams = generateQueryParams(params);
+                                if (queryParams.length > 0) {
+                                    url += "?".concat(queryParams);
+                                }
+                                return [
+                                    4,
+                                    this.api.execute({
+                                        url: url,
+                                        method: method,
+                                        headers: headers
+                                    })
+                                ];
+                            case 2:
+                                response = _state.sent();
+                                return [
+                                    4,
+                                    transformer(response)
+                                ];
+                            case 3:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                            case 4:
+                                error = _state.sent();
+                                console.log("error", "BaseService.request error when request ".concat(path, ". Error: ").concat(error));
+                                throw error;
+                            case 5:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).apply(this, arguments);
+            }
+        }
+    ]);
+    return BaseService;
+}();
+// ../services/src/transforms/information.ts
+var transformInformationUnits = function(data) {
+    return {
+        items: data.items.map(function(item) {
+            return item;
+        }),
+        pageInfo: data.pageInfo
+    };
+};
+// ../services/src/informationUnits.ts
+var InformationUnitsService = /*#__PURE__*/ function(BaseService) {
+    "use strict";
+    _inherits(InformationUnitsService, BaseService);
+    function InformationUnitsService() {
+        _class_call_check(this, InformationUnitsService);
+        return _call_super(this, InformationUnitsService, [
+            "InformationUnits/"
+        ]);
+    }
+    _create_class(InformationUnitsService, [
+        {
+            key: "getList",
+            value: function getList(queries, page, fields, language) {
+                return /*#__PURE__*/ _async_to_generator(function() {
+                    var remainFields, params;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                remainFields = createParams(fields, "Fields");
+                                params = [
+                                    {
+                                        key: "pageSize",
+                                        value: "8"
+                                    },
+                                    {
+                                        key: "PageNumber",
+                                        value: (page - 1).toString()
+                                    },
+                                    {
+                                        key: "Query",
+                                        value: queries
+                                    }
+                                ].concat(_to_consumable_array(remainFields));
+                                if (language != null) {
+                                    language.forEach(function(item) {
+                                        params.push({
+                                            key: "Restrict",
+                                            value: "languages~".concat(item)
+                                        });
+                                    });
+                                }
+                                return [
+                                    4,
+                                    this.request({
+                                        params: params,
+                                        transformer: transformInformationUnits
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "getItem",
+            value: function getItem(id) {
+                return /*#__PURE__*/ _async_to_generator(function() {
+                    var params;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                params = [
+                                    {
+                                        key: "Fields",
+                                        value: "renditions"
+                                    },
+                                    {
+                                        key: "Fields",
+                                        value: "directoryNodes"
+                                    }
+                                ];
+                                return [
+                                    4,
+                                    this.request({
+                                        path: id,
+                                        params: params
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "getLanguages",
+            value: function getLanguages() {
+                return /*#__PURE__*/ _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.request({
+                                        path: "Languages",
+                                        transformer: function(data) {
+                                            return data.map(function(item) {
+                                                return item.value;
+                                            });
+                                        }
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "getSuggestions",
+            value: function getSuggestions(query) {
+                return /*#__PURE__*/ _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.request({
+                                        path: "Suggestions",
+                                        params: [
+                                            {
+                                                key: "prefix",
+                                                value: query
+                                            }
+                                        ],
+                                        transformer: function(data) {
+                                            return data.suggestions.map(function(item) {
+                                                return item.value;
+                                            });
+                                        }
+                                    })
+                                ];
+                            case 1:
+                                return [
+                                    2,
+                                    _state.sent()
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return InformationUnitsService;
+}(BaseService);
+// src/home/layout.tsx
+import { SearchStateWrapper } from "@c-rex/components/search-wrapper";
+// src/home/page.tsx
+import { useRouter } from "next/navigation";
+import { Button } from "@c-rex/ui/button";
+import { AutoComplete } from "@c-rex/components/autocomplete";
+import { ResultList } from "@c-rex/components/result-list";
+import { jsx, jsxs } from "react/jsx-runtime";
+var HomePage = function(param) {
+    var data = param.data;
+    var router = useRouter();
+    var initialValue = null;
+    var onSearch = function(value) {
+        var service = new InformationUnitsService();
+        return service.getSuggestions(value);
+    };
+    var onSelect = function(value) {
+        updateUrlWithParams(router, [
+            {
+                key: "search",
+                value: value.split(" ").join(",")
+            },
+            {
+                key: "operator",
+                value: "OR"
+            },
+            {
+                key: "page",
+                value: "1"
+            }
+        ]);
+    };
+    return /* @__PURE__ */ jsxs("div", {
+        className: "container",
+        children: [
+            /* @__PURE__ */ jsxs("div", {
+                className: "grid grid-cols-12 gap-4 py-6",
+                children: [
+                    /* @__PURE__ */ jsx("div", {
+                        className: "col-span-12 sm:col-span-9 md:col-span-10",
+                        children: /* @__PURE__ */ jsx(AutoComplete, {
+                            initialValue: initialValue !== null && initialValue !== void 0 ? initialValue : "",
+                            onSearch: onSearch,
+                            onSelect: onSelect
+                        })
+                    }),
+                    /* @__PURE__ */ jsx("div", {
+                        className: "col-span-12 sm:col-span-3 md:col-span-2",
+                        children: /* @__PURE__ */ jsx("div", {
+                            className: "flex justify-end",
+                            children: /* @__PURE__ */ jsx(Button, {
+                                variant: "default",
+                                children: "Filters"
+                            })
+                        })
+                    })
+                ]
+            }),
+            /* @__PURE__ */ jsx(ResultList, {
+                items: data.items
+            })
+        ]
+    });
+};
+// src/home/layout.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var loadData = function(param) {
+    var search = param.search, page = param.page, language = param.language;
+    return /*#__PURE__*/ _async_to_generator(function() {
+        var service, pageAux, searchValue, availableLanguages, data, selectedLanguages, aux;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    service = new InformationUnitsService();
+                    pageAux = page != void 0 ? Number(page) : 0;
+                    searchValue = search != void 0 ? search : "";
+                    return [
+                        4,
+                        service.getLanguages()
+                    ];
+                case 1:
+                    availableLanguages = _state.sent();
+                    data = {
+                        items: []
+                    };
+                    selectedLanguages = [];
+                    if (language != void 0) {
+                        aux = language;
+                        selectedLanguages = aux.split(",");
+                    }
+                    if (!searchValue) return [
+                        3,
+                        3
+                    ];
+                    return [
+                        4,
+                        service.getList(searchValue, pageAux, selectedLanguages, [])
+                    ];
+                case 2:
+                    data = _state.sent();
+                    _state.label = 3;
+                case 3:
+                    return [
+                        2,
+                        {
+                            data: data,
+                            filters: {
+                                searchValue: searchValue,
+                                page: pageAux,
+                                selectedLanguage: selectedLanguages,
+                                availableLanguages: availableLanguages
+                            }
+                        }
+                    ];
+            }
+        });
+    })();
+};
+var HomeLayout = function(param) {
+    var searchParams = param.searchParams;
+    return /*#__PURE__*/ _async_to_generator(function() {
+        var _ref, data, filters;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        loadData(searchParams)
+                    ];
+                case 1:
+                    _ref = _state.sent(), data = _ref.data, filters = _ref.filters;
+                    return [
+                        2,
+                        /* @__PURE__ */ jsx2(SearchStateWrapper, {
+                            filters: filters,
+                            children: /* @__PURE__ */ jsx2(HomePage, {
+                                data: data
+                            })
+                        })
+                    ];
+            }
+        });
+    })();
+};
+export { HomeLayout };
+//# sourceMappingURL=layout.esm.js.map