https://jupitergem.com/static/version1789375158/frontend/Swissup/b…/en_US/Swissup_Breeze/js/core/registry.js

1$.registry = (function () {
2    'use strict';
3
4    var data = {},
5        scopeToName = {};
6
7    function toName(name) {
8        if (data[name]) {
9            return name;
10        }
11        return scopeToName[name] || name;
12    }
13
14    return {
15        first: function (name) {
16            return this.get(name)[0];
17        },
18
19        /**
20         * @param {String} name
21         * @param {Element} element
22         * @return {Mixed}
23         */
24        get: function (name, element) {
25            var result = [];
26
27            name = toName(name);
28
29            if (!data[name] || !data[name].objects) {
30                return data[name];
31            }
32
33            if (element) {
34                return data[name].objects.get(element);
35            }
36
37            $.each(data[name].elements, function (index, el) {
38                var instance = $.registry.get(name, el);
39
40                if (!instance) {
41                    return;
42                }
43
44                result.push(instance);
45            });
46
47            return result;
48        },
49
50        /**
51         * @param {String} name
52         * @param {Element} element
53         * @param {Object} component
54         */
55        set: function (name, element, component) {
56            if (!data[name] && component) {
57                data[name] = {
58                    objects: new WeakMap(),
59                    elements: []
60                };
61            }
62
63            if (!component) {
64                component = element;
65                element = false;
66            }
67
68            if (component.__scope) {
69                $.breezemap.uiRegistry.set(component.__scope, component);
70                scopeToName[component.__scope] = name;
71            }
72
73            if (!element) {
74                data[name] = component;
75            } else {
76                data[name].objects.set(element || document.body, component);
77                data[name].elements.push(element || document.body);
78            }
79        },
80
81        /**
82         * @param {String} name
83         * @param {Element} element
84         */
85        delete: function (name, element, skipDestroy) {
86            var instance, index;
87
88            if (name && element) {
89                name = toName(name);
90
91                if (!data[name]) {
92                    return;
93                }
94
95                instance = data[name].objects.get(element);
96                index = data[name].elements.indexOf(element);
97
98                if (index !== -1) {
99                    data[name].elements.splice(index, 1);
100                }
101
102                if (instance?.destroy && !instance.__destroyed && !skipDestroy) {
103                    instance.destroy();
104                    instance.__destroyed = true;
105                }
106
107                if (instance?.__scope) {
108                    $.breezemap.uiRegistry.remove(instance.__scope);
109                }
110
111                return data[name].objects.delete(element);
112            }
113
114            if (name) {
115                return $.each(data[name].elements, function (i, el) {
116                    $.registry.delete(name, el);
117                });
118            }
119
120            $.each(data, function (t) {
121                $.each(data[t].elements || [], function (i, el) {
122                    $.registry.delete(t, el);
123                });
124            });
125
126            $.breezemap.uiRegistry.removeAll();
127        }
128    };
129})();
130
131// Copy of Magento/Ui/view/base/web/js/lib/registry/registry.js
132$.breezemap.uiRegistry = (() => {
133    'use strict';
134
135    var privateData = new WeakMap();
136
137    function getItems(container) {
138        return privateData.get(container).items;
139    }
140
141    function getRequests(container) {
142        return privateData.get(container).requests;
143    }
144
145    function async(name, registry, method) {
146        var args = _.toArray(arguments).slice(3);
147
148        if (_.isString(method)) {
149            registry.get(name, function (component) {
150                component[method].apply(component, args);
151            });
152        } else if (_.isFunction(method)) {
153            registry.get(name, method);
154        } else if (!args.length) {
155            return registry.get(name);
156        }
157    }
158
159    function compare(query, target) {
160        var matches = true,
161            index,
162            keys,
163            key;
164
165        if (!_.isObject(query) || !_.isObject(target)) {
166            return false;

167        }
168
169        keys = Object.getOwnPropertyNames(query);
170        index = keys.length;
171
172        while (matches && index--) {
173            key = keys[index];
174
175            /* eslint-disable eqeqeq */
176            if (target[key] != query[key]) {
177                matches = false;
178            }
179
180            /* eslint-enable eqeqeq */
181        }
182
183        return matches;
184    }
185
186    function explode(query) {
187        var result = {},
188            index,
189            data;
190
191        if (typeof query !== 'string' || !~query.indexOf('=')) {
192            return query;
193        }
194
195        query = query.split(',');
196        index = query.length;
197
198        while (index--) {
199            data = query[index].split('=');
200
201            result[data[0].trim()] = data[1].trim();
202        }
203
204        return result;
205    }
206
207    function find(data, query, findAll) {
208        var iterator,
209            item;
210
211        query = explode(query);
212
213        if (typeof query === 'string') {
214            item = data[query];
215
216            if (findAll) {
217                return item ? [item] : [];
218            }
219
220            return item;
221        }
222
223        iterator = !_.isFunction(query) ?
224            compare.bind(null, query) :
225            query;
226
227        return findAll ?
228            _.filter(data, iterator) :
229            _.find(data, iterator);
230    }
231
232    function Registry() {
233        var data = {
234            items: {},
235            requests: []
236        };
237
238        this._updateRequests = _.debounce(this._updateRequests.bind(this), 10);
239        privateData.set(this, data);
240    }
241
242    Registry.prototype = {
243        constructor: Registry,
244
245        get: function (query, callback) {
246            if (typeof callback !== 'function') {
247                return find(getItems(this), query);
248            }
249
250            this._addRequest(query, callback);
251        },
252
253        set: function (id, item) {
254            getItems(this)[id] = item;
255
256            this._updateRequests();
257
258            return this;
259        },
260
261        remove: function (id) {
262            delete getItems(this)[id];
263
264            return this;
265        },
266
267        removeAll: function () {
268            privateData.get(this).items = {};
269            privateData.get(this).requests = [];
270        },
271
272        filter: function (query) {
273            return find(getItems(this), query, true);
274        },
275
276        has: function (query) {
277            return !!this.get(query);
278        },
279
280        contains: function (item) {
281            return _.contains(getItems(this), item);
282        },
283
284        indexOf: function (item) {
285            return _.findKey(getItems(this), function (elem) {
286                return item === elem;
287            });
288        },
289
290        promise: function (query) {
291            return new Promise(resolve => {
292                this.get(query, resolve);
293            });
294        },
295
296        async: function (query) {
297            return async.bind(null, query, this);
298        },
299
300        create: function () {
301            return new Registry;
302        },
303
304        _addRequest: function (queries, callback) {
305            var request;
306
307            if (!Array.isArray(queries)) {
308                queries = queries ? [queries] : [];
309            }
310
311            request = {
312                queries: queries.map(explode),
313                callback: callback
314            };
315
316            this._canResolve(request) ?
317                this._resolveRequest(request) :
318                getRequests(this).push(request);
319
320            return this;
321        },
322
323        _updateRequests: function () {
324            getRequests(this)
325                .filter(this._canResolve, this)
326                .forEach(this._resolveRequest, this);
327
328            return this;
329        },
330
331        _resolveRequest: function (request) {
332            var requests = getRequests(this),
333                items    = request.queries.map(this.get, this),
334                index    = requests.indexOf(request);
335
336            request.callback.apply(null, items);
337
338            if (~index) {
339                requests.splice(index, 1);
340            }
341
342            return this;
343        },
344
345        _canResolve: function (request) {
346            var queries = request.queries;
347
348            return queries.every(this.has, this);
349        }
350    };
351
352    return new Registry;
353})();