aDriv4 website!

Linux ubuntu-s-2vcpu-4gb-fra1-01 4.15.0-213-generic #224-Ubuntu SMP Mon Jun 19 13:30:12 UTC 2023 x86_64
Apache/2.4.29 (Ubuntu)
134.209.252.102

File Name : wrapper.js

/**
 * Copyright © Magento, Inc. All rights reserved.
 * See COPYING.txt for license details.
 */

/**
 * Utility methods used to wrap and extend functions.
 *
 * @example Usage of a 'wrap' method with arguments delegation.
 *      var multiply = function (a, b) {
 *          return a * b;
 *      };
 *
 *      multiply = module.wrap(multiply, function (orig) {
 *          return 'Result is: ' + orig();
 *      });
 *
 *      multiply(2, 2);
 *      => 'Result is: 4'
 *
 * @example Usage of 'wrapSuper' method.
 *      var multiply = function (a, b) {
 *         return a * b;
 *      };
 *
 *      var obj = {
 *          multiply: module.wrapSuper(multiply, function () {
 *              return 'Result is: ' + this._super();
 *          });
 *      };
 *
 *      obj.multiply(2, 2);
 *      => 'Result is: 4'
 */
define([
    'underscore'
], function (_) {
    'use strict';

/**
     * Checks if string has a '_super' substring.
     */
    var superReg = /\b_super\b/;

return {

/**
         * Wraps target function with a specified wrapper, which will receive
         * reference to the original function as a first argument.
         *
         * @param {Function} target - Function to be wrapped.
         * @param {Function} wrapper - Wrapper function.
         * @returns {Function} Wrapper function.
         */
        wrap: function (target, wrapper) {
            if (!_.isFunction(target) || !_.isFunction(wrapper)) {
                return wrapper;
            }

return function () {
                var args    = _.toArray(arguments),
                    ctx     = this,
                    _super;

/**
                 * Function that will be passed to the wrapper.
                 * If no arguments will be passed to it, then the original
                 * function will be called with an arguments of a wrapper function.
                 */
                _super = function () {
                    var superArgs = arguments.length ? arguments : args.slice(1);

return target.apply(ctx, superArgs);
                };

args.unshift(_super);

return wrapper.apply(ctx, args);
            };
        },

/**
         * Wraps the incoming function to implement support of the '_super' method.
         *
         * @param {Function} target - Function to be wrapped.
         * @param {Function} wrapper - Wrapper function.
         * @returns {Function} Wrapped function.
         */
        wrapSuper: function (target, wrapper) {
            if (!this.hasSuper(wrapper) || !_.isFunction(target)) {
                return wrapper;
            }

return function () {
                var _super  = this._super,
                    args    = arguments,
                    result;

/**
                 * Temporary define '_super' method which
                 * contains call to the original function.
                 */
                this._super = function () {
                    var superArgs = arguments.length ? arguments : args;

return target.apply(this, superArgs);
                };

result = wrapper.apply(this, args);

this._super = _super;

return result;
            };
        },

/**
         * Checks wether the incoming method contains calls of the '_super' method.
         *
         * @param {Function} fn - Function to be checked.
         * @returns {Boolean}
         */
        hasSuper: function (fn) {
            return _.isFunction(fn) && superReg.test(fn);
        },

/**
         * Extends target object with provided extenders.
         * If property in target and extender objects is a function,
         * then it will be wrapped using 'wrap' method.
         *
         * @param {Object} target - Object to be extended.
         * @param {...Object} extenders - Multiple extenders objects.
         * @returns {Object} Modified target object.
         */
        extend: function (target) {
            var extenders = _.toArray(arguments).slice(1),
                iterator = this._extend.bind(this, target);

extenders.forEach(iterator);

return target;
        },

/**
         * Same as the 'extend' method, but operates only on one extender object.
         *
         * @private
         * @param {Object} target
         * @param {Object} extender
         */
        _extend: function (target, extender) {
            _.each(extender, function (value, key) {
                target[key] = this.wrap(target[key], extender[key]);
            }, this);
        }
    };
});

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	0775	2026-05-12 09:17:08
..	dir	-	root/root	0775	2026-05-12 09:17:08
arrays.js	text/plain	4.6 KB	root/root	0664	2026-05-12 09:17:08
compare.js	text/plain	5.51 KB	root/root	0664	2026-05-12 09:17:08
main.js	text/plain	425 B	root/root	0664	2026-05-12 09:17:08
misc.js	text/plain	9.31 KB	root/root	0664	2026-05-12 09:17:08
objects.js	text/plain	12.8 KB	root/root	0664	2026-05-12 09:17:08
strings.js	text/plain	4.44 KB	root/root	0664	2026-05-12 09:17:08
template.js	text/plain	7.43 KB	root/root	0664	2026-05-12 09:17:08
wrapper.js	text/plain	4.59 KB	root/root	0664	2026-05-12 09:17:08

For more Private tool come to me!

https://t.me/aDriv4vz