forked from rDrama/rDrama
206 lines
5.1 KiB
JavaScript
206 lines
5.1 KiB
JavaScript
|
"use strict";
|
||
|
|
||
|
exports.__esModule = true;
|
||
|
exports["default"] = void 0;
|
||
|
|
||
|
var _parser = _interopRequireDefault(require("./parser"));
|
||
|
|
||
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
||
|
|
||
|
var Processor = /*#__PURE__*/function () {
|
||
|
function Processor(func, options) {
|
||
|
this.func = func || function noop() {};
|
||
|
|
||
|
this.funcRes = null;
|
||
|
this.options = options;
|
||
|
}
|
||
|
|
||
|
var _proto = Processor.prototype;
|
||
|
|
||
|
_proto._shouldUpdateSelector = function _shouldUpdateSelector(rule, options) {
|
||
|
if (options === void 0) {
|
||
|
options = {};
|
||
|
}
|
||
|
|
||
|
var merged = Object.assign({}, this.options, options);
|
||
|
|
||
|
if (merged.updateSelector === false) {
|
||
|
return false;
|
||
|
} else {
|
||
|
return typeof rule !== "string";
|
||
|
}
|
||
|
};
|
||
|
|
||
|
_proto._isLossy = function _isLossy(options) {
|
||
|
if (options === void 0) {
|
||
|
options = {};
|
||
|
}
|
||
|
|
||
|
var merged = Object.assign({}, this.options, options);
|
||
|
|
||
|
if (merged.lossless === false) {
|
||
|
return true;
|
||
|
} else {
|
||
|
return false;
|
||
|
}
|
||
|
};
|
||
|
|
||
|
_proto._root = function _root(rule, options) {
|
||
|
if (options === void 0) {
|
||
|
options = {};
|
||
|
}
|
||
|
|
||
|
var parser = new _parser["default"](rule, this._parseOptions(options));
|
||
|
return parser.root;
|
||
|
};
|
||
|
|
||
|
_proto._parseOptions = function _parseOptions(options) {
|
||
|
return {
|
||
|
lossy: this._isLossy(options)
|
||
|
};
|
||
|
};
|
||
|
|
||
|
_proto._run = function _run(rule, options) {
|
||
|
var _this = this;
|
||
|
|
||
|
if (options === void 0) {
|
||
|
options = {};
|
||
|
}
|
||
|
|
||
|
return new Promise(function (resolve, reject) {
|
||
|
try {
|
||
|
var root = _this._root(rule, options);
|
||
|
|
||
|
Promise.resolve(_this.func(root)).then(function (transform) {
|
||
|
var string = undefined;
|
||
|
|
||
|
if (_this._shouldUpdateSelector(rule, options)) {
|
||
|
string = root.toString();
|
||
|
rule.selector = string;
|
||
|
}
|
||
|
|
||
|
return {
|
||
|
transform: transform,
|
||
|
root: root,
|
||
|
string: string
|
||
|
};
|
||
|
}).then(resolve, reject);
|
||
|
} catch (e) {
|
||
|
reject(e);
|
||
|
return;
|
||
|
}
|
||
|
});
|
||
|
};
|
||
|
|
||
|
_proto._runSync = function _runSync(rule, options) {
|
||
|
if (options === void 0) {
|
||
|
options = {};
|
||
|
}
|
||
|
|
||
|
var root = this._root(rule, options);
|
||
|
|
||
|
var transform = this.func(root);
|
||
|
|
||
|
if (transform && typeof transform.then === "function") {
|
||
|
throw new Error("Selector processor returned a promise to a synchronous call.");
|
||
|
}
|
||
|
|
||
|
var string = undefined;
|
||
|
|
||
|
if (options.updateSelector && typeof rule !== "string") {
|
||
|
string = root.toString();
|
||
|
rule.selector = string;
|
||
|
}
|
||
|
|
||
|
return {
|
||
|
transform: transform,
|
||
|
root: root,
|
||
|
string: string
|
||
|
};
|
||
|
}
|
||
|
/**
|
||
|
* Process rule into a selector AST.
|
||
|
*
|
||
|
* @param rule {postcss.Rule | string} The css selector to be processed
|
||
|
* @param options The options for processing
|
||
|
* @returns {Promise<parser.Root>} The AST of the selector after processing it.
|
||
|
*/
|
||
|
;
|
||
|
|
||
|
_proto.ast = function ast(rule, options) {
|
||
|
return this._run(rule, options).then(function (result) {
|
||
|
return result.root;
|
||
|
});
|
||
|
}
|
||
|
/**
|
||
|
* Process rule into a selector AST synchronously.
|
||
|
*
|
||
|
* @param rule {postcss.Rule | string} The css selector to be processed
|
||
|
* @param options The options for processing
|
||
|
* @returns {parser.Root} The AST of the selector after processing it.
|
||
|
*/
|
||
|
;
|
||
|
|
||
|
_proto.astSync = function astSync(rule, options) {
|
||
|
return this._runSync(rule, options).root;
|
||
|
}
|
||
|
/**
|
||
|
* Process a selector into a transformed value asynchronously
|
||
|
*
|
||
|
* @param rule {postcss.Rule | string} The css selector to be processed
|
||
|
* @param options The options for processing
|
||
|
* @returns {Promise<any>} The value returned by the processor.
|
||
|
*/
|
||
|
;
|
||
|
|
||
|
_proto.transform = function transform(rule, options) {
|
||
|
return this._run(rule, options).then(function (result) {
|
||
|
return result.transform;
|
||
|
});
|
||
|
}
|
||
|
/**
|
||
|
* Process a selector into a transformed value synchronously.
|
||
|
*
|
||
|
* @param rule {postcss.Rule | string} The css selector to be processed
|
||
|
* @param options The options for processing
|
||
|
* @returns {any} The value returned by the processor.
|
||
|
*/
|
||
|
;
|
||
|
|
||
|
_proto.transformSync = function transformSync(rule, options) {
|
||
|
return this._runSync(rule, options).transform;
|
||
|
}
|
||
|
/**
|
||
|
* Process a selector into a new selector string asynchronously.
|
||
|
*
|
||
|
* @param rule {postcss.Rule | string} The css selector to be processed
|
||
|
* @param options The options for processing
|
||
|
* @returns {string} the selector after processing.
|
||
|
*/
|
||
|
;
|
||
|
|
||
|
_proto.process = function process(rule, options) {
|
||
|
return this._run(rule, options).then(function (result) {
|
||
|
return result.string || result.root.toString();
|
||
|
});
|
||
|
}
|
||
|
/**
|
||
|
* Process a selector into a new selector string synchronously.
|
||
|
*
|
||
|
* @param rule {postcss.Rule | string} The css selector to be processed
|
||
|
* @param options The options for processing
|
||
|
* @returns {string} the selector after processing.
|
||
|
*/
|
||
|
;
|
||
|
|
||
|
_proto.processSync = function processSync(rule, options) {
|
||
|
var result = this._runSync(rule, options);
|
||
|
|
||
|
return result.string || result.root.toString();
|
||
|
};
|
||
|
|
||
|
return Processor;
|
||
|
}();
|
||
|
|
||
|
exports["default"] = Processor;
|
||
|
module.exports = exports.default;
|