https://ladya.ru/bitrix/templates/aspro_max/js/app.js?17509353285512

1BX.namespace("Aspro");
2
3BX.Aspro.Utils = {
4  isFunction: (func) => {
5    return typeof func == "function" || typeof window[func] === "function";
6  },
7
8  readyDOM: (callback) => {
9    if (document.readyState !== "loading") {
10      callback();
11    } else {
12      document.addEventListener("DOMContentLoaded", callback);
13    }
14  },
15};
16
17BX.namespace("Aspro.Loader");
18BX.namespace("Aspro.Observer");
19
20(() => {
21  /**
22   * class JAsproLoader
23   */
24
25  const addedCss = [];
26  const addedJs = [];
27  const addedExt = [];
28
29  class JAsproLoader {
30    constructor() {}
31
32    addCss(...items) {
33      return new Promise((resolve, reject) => {
34        items = items.filter((css) => {
35          return BX.type.isString(css) && !~addedCss.indexOf(css);
36        });
37
38        if (items.length) {
39          BX.loadCSS(items, () => {
40            items.forEach((css) => {
41              addedCss.push(css);
42            });
43
44            resolve();
45          });
46        } else {
47          resolve();
48        }
49      });
50    }
51
52    addJs(...items) {
53      return new Promise((resolve, reject) => {
54        items = items.filter((js) => {
55          return BX.type.isString(js) && !~addedJs.indexOf(js);
56        });
57
58        if (items.length) {
59          BX.loadScript(items, () => {
60            items.forEach((js) => {
61              addedJs.push(js);
62            });
63
64            resolve();
65          });
66        } else {
67          resolve();
68        }
69      });
70    }
71
72    addExt(...extensions) {
73      return new Promise((resolve, reject) => {
74        extensions = extensions.map((extension) => {
75          return `aspro_${extension}`;
76        });
77
78        extensions = extensions.filter((extension) => {
79          return BX.type.isString(extension) && !~addedExt.indexOf(extension);
80        });
81
82        if (extensions.length) {
83          BX.loadExt(extensions).then(() => {
84            extensions.forEach((extension) => {
85              addedExt.push(extension);
86            });
87
88            resolve();
89          });
90        } else {
91          resolve();
92        }
93      });
94    }
95
96    added(item) {
97      if (BX.type.isString(item) && item) {
98        return !!~addedCss.indexOf(item) || !!~addedJs.indexOf(item) || !!~addedExt.indexOf(`aspro_${item}`);
99      } else {
100        return {
101          ext: addedExt,
102          css: addedCss,
103          js: addedJs,
104        };
105      }
106    }
107
108    add(params) {
109      params = BX.type.isObject(params) ? params : {};
110      let extensions = params.ext ? (BX.type.isArray(params.ext) ? params.ext : [params.ext]) : [];
111      let cssItems = params.css ? (BX.type.isArray(params.css) ? params.css : [params.css]) : [];
112      let jsItems = params.js ? (BX.type.isArray(params.js) ? params.js : [params.js]) : [];
113
114      return new Promise((resolve, reject) => {
115        this.addExt(...extensions).then(() => {
116          this.addCss(...cssItems).then(() => {
117            this.addJs(...jsItems).then(() => {
118              resolve();
119            });
120          });
121        });
122      });
123    }
124
125    once(params) {
126      params = BX.type.isObject(params) ? params : {};
127
128      params.appear = BX.type.isString(params.appear)
129        ? [params.appear]
130        : BX.type.isArray(params.appear)
131        ? params.appear
132        : null;
133      params.add = BX.type.isObject(params.add) ? params.add : null;
134
135      return new Promise((resolve, reject) => {
136        if (params.appear) {
137          BX.Aspro.Observer.appear(...params.appear).then(() => {
138            if (params.add) {
139              this.add(params.add).then(resolve);
140            } else {
141              resolve();
142            }
143          });
144        } else if (params.add) {
145          this.add(params.add).then(resolve);
146        } else {
147          resolve();
148        }
149      });
150    }
151  }
152
153  BX.Aspro.Loader = new JAsproLoader();
154
155  /**
156   * class JAsproObserver
157   */
158
159  const intersectionConfig = {
160    root: null,
161    rootMargin: "0px",
162    threshold: 0,
163  };
164
165  class JAsproObserver {
166    constructor() {
167      this.mkIntersectionConfig();
168    }
169
170    mkIntersectionConfig(config) {
171      if (BX.type.isObject(config)) {
172        intersectionConfig.root = config.root;
173        intersectionConfig.rootMargin = config.rootMargin;
174        intersectionConfig.threshold = config.threshold;
175      } else {
176        intersectionConfig.rootMargin = "0px";
177      }
178    }
179
180    appear(node, config) {
181      config = BX.type.isObject(config) && config ? config : intersectionConfig;
182
183      return new Promise((resolve, reject) => {
184        if (BX.type.isString(node)) {
185          let nodes = document.querySelectorAll(node);
186          if (nodes.length) {
187            let observer = new IntersectionObserver((entries, observer) => {

188              entries.forEach((entry) => {
189                if (entry.isIntersecting) {
190                  observer.unobserve(entry.target);
191
192                  resolve();
193                }
194              });
195            }, config);
196
197            nodes.forEach((node) => {
198              observer.observe(node);
199            });
200          } else {
201            resolve();
202          }
203        } else if (BX.type.isDomNode(node)) {
204          new IntersectionObserver((entries, observer) => {
205            entries.forEach((entry) => {
206              if (entry.isIntersecting) {
207                observer.unobserve(entry.target);
208
209                resolve();
210              }
211            });
212          }, config).observe(node);
213        } else {
214          resolve();
215        }
216      });
217    }
218  }
219
220  BX.Aspro.Observer = new JAsproObserver();
221})();