less 4.4.2 → 4.6.0

package/lib/less/tree/mixin-call.js

@@ -1,60 +1,127 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var node_1 = tslib_1.__importDefault(require("./node"));
-var selector_1 = tslib_1.__importDefault(require("./selector"));
-var mixin_definition_1 = tslib_1.__importDefault(require("./mixin-definition"));
-var default_1 = tslib_1.__importDefault(require("../functions/default"));
-var MixinCall = function (elements, args, index, currentFileInfo, important) {
-    this.selector = new selector_1.default(elements);
-    this.arguments = args || [];
-    this._index = index;
-    this._fileInfo = currentFileInfo;
-    this.important = important;
-    this.allowRoot = true;
-    this.setParent(this.selector, this);
-};
-MixinCall.prototype = Object.assign(new node_1.default(), {
-    type: 'MixinCall',
-    accept: function (visitor) {
+// @ts-check
+/** @import { EvalContext, TreeVisitor, FileInfo } from './node.js' */
+/** @import { FunctionRegistry } from './nested-at-rule.js' */
+import Node from './node.js';
+import Selector from './selector.js';
+import MixinDefinition from './mixin-definition.js';
+import defaultFunc from '../functions/default.js';
+
+/**
+ * @typedef {{ name?: string, value: Node, expand?: boolean }} MixinArg
+ */
+
+/**
+ * @typedef {Node & {
+ *   rules?: Node[],
+ *   selectors?: Selector[],
+ *   originalRuleset?: Node,
+ *   matchArgs: (args: MixinArg[] | null, context: EvalContext) => boolean,
+ *   matchCondition?: (args: MixinArg[] | null, context: EvalContext) => boolean,
+ *   find: (selector: Selector, self?: Node | null, filter?: (rule: Node) => boolean) => Array<{ rule: Node & { rules?: Node[], originalRuleset?: Node, matchArgs: Function, matchCondition?: Function, evalCall?: Function }, path: Node[] }>,
+ *   functionRegistry?: FunctionRegistry
+ * }} MixinSearchFrame
+ */
+
+class MixinCall extends Node {
+    get type() { return 'MixinCall'; }
+
+    /**
+     * @param {import('./element.js').default[]} elements
+     * @param {MixinArg[]} [args]
+     * @param {number} [index]
+     * @param {FileInfo} [currentFileInfo]
+     * @param {string} [important]
+     */
+    constructor(elements, args, index, currentFileInfo, important) {
+        super();
+        /** @type {Selector} */
+        this.selector = new Selector(elements);
+        /** @type {MixinArg[]} */
+        this.arguments = args || [];
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        /** @type {string | undefined} */
+        this.important = important;
+        this.allowRoot = true;
+        this.setParent(this.selector, /** @type {Node} */ (/** @type {unknown} */ (this)));
+    }
+
+    /** @param {TreeVisitor} visitor */
+    accept(visitor) {
         if (this.selector) {
-            this.selector = visitor.visit(this.selector);
+            this.selector = /** @type {Selector} */ (visitor.visit(this.selector));
         }
         if (this.arguments.length) {
-            this.arguments = visitor.visitArray(this.arguments);
+            this.arguments = /** @type {MixinArg[]} */ (/** @type {unknown} */ (visitor.visitArray(/** @type {Node[]} */ (/** @type {unknown} */ (this.arguments)))));
         }
-    },
-    eval: function (context) {
-        var mixins;
-        var mixin;
-        var mixinPath;
-        var args = [];
-        var arg;
-        var argValue;
-        var rules = [];
-        var match = false;
-        var i;
-        var m;
-        var f;
-        var isRecursive;
-        var isOneFound;
-        var candidates = [];
-        var candidate;
-        var conditionResult = [];
-        var defaultResult;
-        var defFalseEitherCase = -1;
-        var defNone = 0;
-        var defTrue = 1;
-        var defFalse = 2;
-        var count;
-        var originalRuleset;
-        var noArgumentsFilter;
-        this.selector = this.selector.eval(context);
+    }
+
+    /**
+     * @param {EvalContext} context
+     * @returns {Node}
+     */
+    eval(context) {
+        /** @type {{ rule: Node & { rules?: Node[], originalRuleset?: Node, matchArgs: Function, matchCondition?: Function, evalCall?: Function }, path: Node[] }[] | undefined} */
+        let mixins;
+        /** @type {Node & { rules?: Node[], originalRuleset?: Node, matchArgs: Function, matchCondition?: Function, evalCall?: Function }} */
+        let mixin;
+        /** @type {Node[]} */
+        let mixinPath;
+        /** @type {MixinArg[]} */
+        const args = [];
+        /** @type {MixinArg} */
+        let arg;
+        /** @type {Node} */
+        let argValue;
+        /** @type {Node[]} */
+        const rules = [];
+        let match = false;
+        /** @type {number} */
+        let i;
+        /** @type {number} */
+        let m;
+        /** @type {number} */
+        let f;
+        /** @type {boolean} */
+        let isRecursive;
+        /** @type {boolean | undefined} */
+        let isOneFound;
+        /** @type {{ mixin: Node & { rules?: Node[], originalRuleset?: Node, matchArgs: Function, matchCondition?: Function, evalCall?: Function }, group: number }[]} */
+        const candidates = [];
+        /** @type {{ mixin: Node & { rules?: Node[], originalRuleset?: Node, matchArgs: Function, matchCondition?: Function, evalCall?: Function }, group: number } | number} */
+        let candidate;
+        /** @type {boolean[]} */
+        const conditionResult = [];
+        /** @type {number | undefined} */
+        let defaultResult;
+        const defFalseEitherCase = -1;
+        const defNone = 0;
+        const defTrue = 1;
+        const defFalse = 2;
+        /** @type {number[]} */
+        let count;
+        /** @type {Node | undefined} */
+        let originalRuleset;
+        /** @type {((rule: MixinSearchFrame) => boolean) | undefined} */
+        let noArgumentsFilter;
+
+        this.selector = /** @type {Selector} */ (this.selector.eval(context));
+
+        /**
+         * @param {Node & { matchCondition?: Function }} mixin
+         * @param {Node[]} mixinPath
+         */
         function calcDefGroup(mixin, mixinPath) {
-            var f, p, namespace;
+            /** @type {number} */
+            let f;
+            /** @type {number} */
+            let p;
+            /** @type {Node & { matchCondition?: Function }} */
+            let namespace;
+
             for (f = 0; f < 2; f++) {
                 conditionResult[f] = true;
-                default_1.default.value(f);
+                defaultFunc.value(f);
                 for (p = 0; p < mixinPath.length && conditionResult[f]; p++) {
                     namespace = mixinPath[p];
                     if (namespace.matchCondition) {
@@ -70,37 +137,42 @@ MixinCall.prototype = Object.assign(new node_1.default(), {
                     return conditionResult[1] ?
                         defTrue : defFalse;
                 }
+
                 return defNone;
             }
             return defFalseEitherCase;
         }
+
         for (i = 0; i < this.arguments.length; i++) {
             arg = this.arguments[i];
             argValue = arg.value.eval(context);
             if (arg.expand && Array.isArray(argValue.value)) {
-                argValue = argValue.value;
-                for (m = 0; m < argValue.length; m++) {
-                    args.push({ value: argValue[m] });
+                const expandedValues = /** @type {Node[]} */ (argValue.value);
+                for (m = 0; m < expandedValues.length; m++) {
+                    args.push({value: expandedValues[m]});
                 }
-            }
-            else {
-                args.push({ name: arg.name, value: argValue });
+            } else {
+                args.push({name: arg.name, value: argValue});
             }
         }
-        noArgumentsFilter = function (rule) { return rule.matchArgs(null, context); };
+
+        noArgumentsFilter = function(/** @type {MixinSearchFrame} */ rule) {return rule.matchArgs(null, context);};
+
         for (i = 0; i < context.frames.length; i++) {
-            if ((mixins = context.frames[i].find(this.selector, null, noArgumentsFilter)).length > 0) {
+            if ((mixins = /** @type {MixinSearchFrame} */ (context.frames[i]).find(this.selector, null, /** @type {(rule: Node) => boolean} */ (/** @type {unknown} */ (noArgumentsFilter)))).length > 0) {
                 isOneFound = true;
+
                 // To make `default()` function independent of definition order we have two "subpasses" here.
                 // At first we evaluate each guard *twice* (with `default() == true` and `default() == false`),
                 // and build candidate list with corresponding flags. Then, when we know all possible matches,
                 // we make a final decision.
+
                 for (m = 0; m < mixins.length; m++) {
                     mixin = mixins[m].rule;
                     mixinPath = mixins[m].path;
                     isRecursive = false;
                     for (f = 0; f < context.frames.length; f++) {
-                        if ((!(mixin instanceof mixin_definition_1.default)) && mixin === (context.frames[f].originalRuleset || context.frames[f])) {
+                        if ((!(mixin instanceof MixinDefinition)) && mixin === (/** @type {Node & { originalRuleset?: Node }} */ (context.frames[f]).originalRuleset || context.frames[f])) {
                             isRecursive = true;
                             break;
                         }
@@ -108,89 +180,100 @@ MixinCall.prototype = Object.assign(new node_1.default(), {
                     if (isRecursive) {
                         continue;
                     }
+
                     if (mixin.matchArgs(args, context)) {
-                        candidate = { mixin: mixin, group: calcDefGroup(mixin, mixinPath) };
-                        if (candidate.group !== defFalseEitherCase) {
-                            candidates.push(candidate);
+                        candidate = {mixin, group: calcDefGroup(mixin, mixinPath)};
+
+                        if (/** @type {{ mixin: Node, group: number }} */ (candidate).group !== defFalseEitherCase) {
+                            candidates.push(/** @type {{ mixin: Node & { rules?: Node[], originalRuleset?: Node, matchArgs: Function, matchCondition?: Function, evalCall?: Function }, group: number }} */ (candidate));
                         }
+
                         match = true;
                     }
                 }
-                default_1.default.reset();
+
+                defaultFunc.reset();
+
                 count = [0, 0, 0];
                 for (m = 0; m < candidates.length; m++) {
                     count[candidates[m].group]++;
                 }
+
                 if (count[defNone] > 0) {
                     defaultResult = defFalse;
-                }
-                else {
+                } else {
                     defaultResult = defTrue;
                     if ((count[defTrue] + count[defFalse]) > 1) {
                         throw { type: 'Runtime',
-                            message: "Ambiguous use of `default()` found when matching for `".concat(this.format(args), "`"),
+                            message: `Ambiguous use of \`default()\` found when matching for \`${this.format(args)}\``,
                             index: this.getIndex(), filename: this.fileInfo().filename };
                     }
                 }
+
                 for (m = 0; m < candidates.length; m++) {
                     candidate = candidates[m].group;
                     if ((candidate === defNone) || (candidate === defaultResult)) {
                         try {
                             mixin = candidates[m].mixin;
-                            if (!(mixin instanceof mixin_definition_1.default)) {
-                                originalRuleset = mixin.originalRuleset || mixin;
-                                mixin = new mixin_definition_1.default('', [], mixin.rules, null, false, null, originalRuleset.visibilityInfo());
-                                mixin.originalRuleset = originalRuleset;
+                            if (!(mixin instanceof MixinDefinition)) {
+                                originalRuleset = /** @type {Node & { originalRuleset?: Node }} */ (mixin).originalRuleset || mixin;
+                                mixin = new MixinDefinition('', [], mixin.rules, null, false, null, originalRuleset.visibilityInfo());
+                                /** @type {Node & { originalRuleset?: Node }} */ (mixin).originalRuleset = originalRuleset;
                             }
-                            var newRules = mixin.evalCall(context, args, this.important).rules;
+                            const newRules = /** @type {MixinDefinition} */ (mixin).evalCall(context, args, this.important).rules;
                             this._setVisibilityToReplacement(newRules);
                             Array.prototype.push.apply(rules, newRules);
-                        }
-                        catch (e) {
-                            throw { message: e.message, index: this.getIndex(), filename: this.fileInfo().filename, stack: e.stack };
+                        } catch (e) {
+                            throw { .../** @type {object} */ (e), index: this.getIndex(), filename: this.fileInfo().filename };
                         }
                     }
                 }
+
                 if (match) {
-                    return rules;
+                    return /** @type {Node} */ (/** @type {unknown} */ (rules));
                 }
             }
         }
         if (isOneFound) {
-            throw { type: 'Runtime',
-                message: "No matching definition was found for `".concat(this.format(args), "`"),
-                index: this.getIndex(), filename: this.fileInfo().filename };
+            throw { type:    'Runtime',
+                message: `No matching definition was found for \`${this.format(args)}\``,
+                index:   this.getIndex(), filename: this.fileInfo().filename };
+        } else {
+            throw { type:    'Name',
+                message: `${this.selector.toCSS(/** @type {EvalContext} */ ({})).trim()} is undefined`,
+                index:   this.getIndex(), filename: this.fileInfo().filename };
         }
-        else {
-            throw { type: 'Name',
-                message: "".concat(this.selector.toCSS().trim(), " is undefined"),
-                index: this.getIndex(), filename: this.fileInfo().filename };
-        }
-    },
-    _setVisibilityToReplacement: function (replacement) {
-        var i, rule;
+    }
+
+    /** @param {Node[]} replacement */
+    _setVisibilityToReplacement(replacement) {
+        /** @type {number} */
+        let i;
+        /** @type {Node} */
+        let rule;
         if (this.blocksVisibility()) {
             for (i = 0; i < replacement.length; i++) {
                 rule = replacement[i];
                 rule.addVisibilityBlock();
             }
         }
-    },
-    format: function (args) {
-        return "".concat(this.selector.toCSS().trim(), "(").concat(args ? args.map(function (a) {
-            var argValue = '';
+    }
+
+    /** @param {MixinArg[]} args */
+    format(args) {
+        return `${this.selector.toCSS(/** @type {EvalContext} */ ({})).trim()}(${args ? args.map(function (/** @type {MixinArg} */ a) {
+            let argValue = '';
             if (a.name) {
-                argValue += "".concat(a.name, ":");
+                argValue += `${a.name}:`;
             }
             if (a.value.toCSS) {
-                argValue += a.value.toCSS();
-            }
-            else {
+                argValue += a.value.toCSS(/** @type {EvalContext} */ ({}));
+            } else {
                 argValue += '???';
             }
             return argValue;
-        }).join(', ') : '', ")");
+        }).join(', ') : ''})`;
     }
-});
-exports.default = MixinCall;
-//# sourceMappingURL=mixin-call.js.map
+}
+
+export default MixinCall;