katoikia-app/web-ui/web-react/node_modules/postcss-custom-properties/index.cjs.js

553 lines
18 KiB
JavaScript

'use strict';
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
var postcss = _interopDefault(require('postcss'));
var valueParser = _interopDefault(require('postcss-values-parser'));
var fs = _interopDefault(require('fs'));
var path = _interopDefault(require('path'));
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _asyncToGenerator(fn) {
return function () {
var self = this,
args = arguments;
return new Promise(function (resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
function parse(string) {
return valueParser(string).parse();
}
function isBlockIgnored(ruleOrDeclaration) {
var rule = ruleOrDeclaration.selector ? ruleOrDeclaration : ruleOrDeclaration.parent;
return /(!\s*)?postcss-custom-properties:\s*off\b/i.test(rule.toString());
}
function isRuleIgnored(rule) {
var previous = rule.prev();
return Boolean(isBlockIgnored(rule) || previous && previous.type === 'comment' && /(!\s*)?postcss-custom-properties:\s*ignore\s+next\b/i.test(previous.text));
}
function getCustomPropertiesFromRoot(root, opts) {
// initialize custom selectors
const customPropertiesFromHtmlElement = {};
const customPropertiesFromRootPseudo = {}; // for each html or :root rule
root.nodes.slice().forEach(rule => {
const customPropertiesObject = isHtmlRule(rule) ? customPropertiesFromHtmlElement : isRootRule(rule) ? customPropertiesFromRootPseudo : null; // for each custom property
if (customPropertiesObject) {
rule.nodes.slice().forEach(decl => {
if (isCustomDecl(decl) && !isBlockIgnored(decl)) {
const prop = decl.prop; // write the parsed value to the custom property
customPropertiesObject[prop] = parse(decl.value).nodes; // conditionally remove the custom property declaration
if (!opts.preserve) {
decl.remove();
}
}
}); // conditionally remove the empty html or :root rule
if (!opts.preserve && isEmptyParent(rule) && !isBlockIgnored(rule)) {
rule.remove();
}
}
}); // return all custom properties, preferring :root properties over html properties
return Object.assign({}, customPropertiesFromHtmlElement, customPropertiesFromRootPseudo);
} // match html and :root rules
const htmlSelectorRegExp = /^html$/i;
const rootSelectorRegExp = /^:root$/i;
const customPropertyRegExp = /^--[A-z][\w-]*$/; // whether the node is an html or :root rule
const isHtmlRule = node => node.type === 'rule' && htmlSelectorRegExp.test(node.selector) && Object(node.nodes).length;
const isRootRule = node => node.type === 'rule' && rootSelectorRegExp.test(node.selector) && Object(node.nodes).length; // whether the node is an custom property
const isCustomDecl = node => node.type === 'decl' && customPropertyRegExp.test(node.prop); // whether the node is a parent without children
const isEmptyParent = node => Object(node.nodes).length === 0;
/* Get Custom Properties from CSS File
/* ========================================================================== */
function getCustomPropertiesFromCSSFile(_x) {
return _getCustomPropertiesFromCSSFile.apply(this, arguments);
}
/* Get Custom Properties from Object
/* ========================================================================== */
function _getCustomPropertiesFromCSSFile() {
_getCustomPropertiesFromCSSFile = _asyncToGenerator(function* (from) {
const css = yield readFile(from);
const root = postcss.parse(css, {
from
});
return getCustomPropertiesFromRoot(root, {
preserve: true
});
});
return _getCustomPropertiesFromCSSFile.apply(this, arguments);
}
function getCustomPropertiesFromObject(object) {
const customProperties = Object.assign({}, Object(object).customProperties, Object(object)['custom-properties']);
for (const key in customProperties) {
customProperties[key] = parse(String(customProperties[key])).nodes;
}
return customProperties;
}
/* Get Custom Properties from JSON file
/* ========================================================================== */
function getCustomPropertiesFromJSONFile(_x2) {
return _getCustomPropertiesFromJSONFile.apply(this, arguments);
}
/* Get Custom Properties from JS file
/* ========================================================================== */
function _getCustomPropertiesFromJSONFile() {
_getCustomPropertiesFromJSONFile = _asyncToGenerator(function* (from) {
const object = yield readJSON(from);
return getCustomPropertiesFromObject(object);
});
return _getCustomPropertiesFromJSONFile.apply(this, arguments);
}
function getCustomPropertiesFromJSFile(_x3) {
return _getCustomPropertiesFromJSFile.apply(this, arguments);
}
/* Get Custom Properties from Imports
/* ========================================================================== */
function _getCustomPropertiesFromJSFile() {
_getCustomPropertiesFromJSFile = _asyncToGenerator(function* (from) {
const object = yield Promise.resolve(require(from));
return getCustomPropertiesFromObject(object);
});
return _getCustomPropertiesFromJSFile.apply(this, arguments);
}
function getCustomPropertiesFromImports(sources) {
return sources.map(source => {
if (source instanceof Promise) {
return source;
} else if (source instanceof Function) {
return source();
} // read the source as an object
const opts = source === Object(source) ? source : {
from: String(source)
}; // skip objects with Custom Properties
if (opts.customProperties || opts['custom-properties']) {
return opts;
} // source pathname
const from = path.resolve(String(opts.from || '')); // type of file being read from
const type = (opts.type || path.extname(from).slice(1)).toLowerCase();
return {
type,
from
};
}).reduce(
/*#__PURE__*/
function () {
var _ref = _asyncToGenerator(function* (customProperties, source) {
const _ref2 = yield source,
type = _ref2.type,
from = _ref2.from;
if (type === 'css') {
return Object.assign((yield customProperties), (yield getCustomPropertiesFromCSSFile(from)));
}
if (type === 'js') {
return Object.assign((yield customProperties), (yield getCustomPropertiesFromJSFile(from)));
}
if (type === 'json') {
return Object.assign((yield customProperties), (yield getCustomPropertiesFromJSONFile(from)));
}
return Object.assign((yield customProperties), (yield getCustomPropertiesFromObject((yield source))));
});
return function (_x4, _x5) {
return _ref.apply(this, arguments);
};
}(), {});
}
/* Helper utilities
/* ========================================================================== */
const readFile = from => new Promise((resolve, reject) => {
fs.readFile(from, 'utf8', (error, result) => {
if (error) {
reject(error);
} else {
resolve(result);
}
});
});
const readJSON =
/*#__PURE__*/
function () {
var _ref3 = _asyncToGenerator(function* (from) {
return JSON.parse((yield readFile(from)));
});
return function readJSON(_x6) {
return _ref3.apply(this, arguments);
};
}();
function transformValueAST(root, customProperties) {
if (root.nodes && root.nodes.length) {
root.nodes.slice().forEach(child => {
if (isVarFunction(child)) {
// eslint-disable-next-line no-unused-vars
const _child$nodes$slice = child.nodes.slice(1, -1),
propertyNode = _child$nodes$slice[0],
comma = _child$nodes$slice[1],
fallbacks = _child$nodes$slice.slice(2);
const name = propertyNode.value;
if (name in Object(customProperties)) {
// conditionally replace a known custom property
const nodes = asClonedArrayWithBeforeSpacing(customProperties[name], child.raws.before);
child.replaceWith(...nodes);
retransformValueAST({
nodes
}, customProperties, name);
} else if (fallbacks.length) {
// conditionally replace a custom property with a fallback
const index = root.nodes.indexOf(child);
if (index !== -1) {
root.nodes.splice(index, 1, ...asClonedArrayWithBeforeSpacing(fallbacks, child.raws.before));
}
transformValueAST(root, customProperties);
}
} else {
transformValueAST(child, customProperties);
}
});
}
return root;
} // retransform the current ast without a custom property (to prevent recursion)
function retransformValueAST(root, customProperties, withoutProperty) {
const nextCustomProperties = Object.assign({}, customProperties);
delete nextCustomProperties[withoutProperty];
return transformValueAST(root, nextCustomProperties);
} // match var() functions
const varRegExp = /^var$/i; // whether the node is a var() function
const isVarFunction = node => node.type === 'func' && varRegExp.test(node.value) && Object(node.nodes).length > 0; // return an array with its nodes cloned, preserving the raw
const asClonedArrayWithBeforeSpacing = (array, beforeSpacing) => {
const clonedArray = asClonedArray(array, null);
if (clonedArray[0]) {
clonedArray[0].raws.before = beforeSpacing;
}
return clonedArray;
}; // return an array with its nodes cloned
const asClonedArray = (array, parent) => array.map(node => asClonedNode(node, parent)); // return a cloned node
const asClonedNode = (node, parent) => {
const cloneNode = new node.constructor(node);
for (const key in node) {
if (key === 'parent') {
cloneNode.parent = parent;
} else if (Object(node[key]).constructor === Array) {
cloneNode[key] = asClonedArray(node.nodes, cloneNode);
} else if (Object(node[key]).constructor === Object) {
cloneNode[key] = Object.assign({}, node[key]);
}
}
return cloneNode;
};
var transformProperties = ((root, customProperties, opts) => {
// walk decls that can be transformed
root.walkDecls(decl => {
if (isTransformableDecl(decl) && !isRuleIgnored(decl)) {
const originalValue = decl.value;
const valueAST = parse(originalValue);
const value = String(transformValueAST(valueAST, customProperties)); // conditionally transform values that have changed
if (value !== originalValue) {
if (opts.preserve) {
decl.cloneBefore({
value
});
} else {
decl.value = value;
}
}
}
});
}); // match custom properties
const customPropertyRegExp$1 = /^--[A-z][\w-]*$/; // match custom property inclusions
const customPropertiesRegExp = /(^|[^\w-])var\([\W\w]+\)/; // whether the declaration should be potentially transformed
const isTransformableDecl = decl => !customPropertyRegExp$1.test(decl.prop) && customPropertiesRegExp.test(decl.value);
/* Write Custom Properties to CSS File
/* ========================================================================== */
function writeCustomPropertiesToCssFile(_x, _x2) {
return _writeCustomPropertiesToCssFile.apply(this, arguments);
}
/* Write Custom Properties to JSON file
/* ========================================================================== */
function _writeCustomPropertiesToCssFile() {
_writeCustomPropertiesToCssFile = _asyncToGenerator(function* (to, customProperties) {
const cssContent = Object.keys(customProperties).reduce((cssLines, name) => {
cssLines.push(`\t${name}: ${customProperties[name]};`);
return cssLines;
}, []).join('\n');
const css = `:root {\n${cssContent}\n}\n`;
yield writeFile(to, css);
});
return _writeCustomPropertiesToCssFile.apply(this, arguments);
}
function writeCustomPropertiesToJsonFile(_x3, _x4) {
return _writeCustomPropertiesToJsonFile.apply(this, arguments);
}
/* Write Custom Properties to Common JS file
/* ========================================================================== */
function _writeCustomPropertiesToJsonFile() {
_writeCustomPropertiesToJsonFile = _asyncToGenerator(function* (to, customProperties) {
const jsonContent = JSON.stringify({
'custom-properties': customProperties
}, null, ' ');
const json = `${jsonContent}\n`;
yield writeFile(to, json);
});
return _writeCustomPropertiesToJsonFile.apply(this, arguments);
}
function writeCustomPropertiesToCjsFile(_x5, _x6) {
return _writeCustomPropertiesToCjsFile.apply(this, arguments);
}
/* Write Custom Properties to Module JS file
/* ========================================================================== */
function _writeCustomPropertiesToCjsFile() {
_writeCustomPropertiesToCjsFile = _asyncToGenerator(function* (to, customProperties) {
const jsContents = Object.keys(customProperties).reduce((jsLines, name) => {
jsLines.push(`\t\t'${escapeForJS(name)}': '${escapeForJS(customProperties[name])}'`);
return jsLines;
}, []).join(',\n');
const js = `module.exports = {\n\tcustomProperties: {\n${jsContents}\n\t}\n};\n`;
yield writeFile(to, js);
});
return _writeCustomPropertiesToCjsFile.apply(this, arguments);
}
function writeCustomPropertiesToMjsFile(_x7, _x8) {
return _writeCustomPropertiesToMjsFile.apply(this, arguments);
}
/* Write Custom Properties to Exports
/* ========================================================================== */
function _writeCustomPropertiesToMjsFile() {
_writeCustomPropertiesToMjsFile = _asyncToGenerator(function* (to, customProperties) {
const mjsContents = Object.keys(customProperties).reduce((mjsLines, name) => {
mjsLines.push(`\t'${escapeForJS(name)}': '${escapeForJS(customProperties[name])}'`);
return mjsLines;
}, []).join(',\n');
const mjs = `export const customProperties = {\n${mjsContents}\n};\n`;
yield writeFile(to, mjs);
});
return _writeCustomPropertiesToMjsFile.apply(this, arguments);
}
function writeCustomPropertiesToExports(customProperties, destinations) {
return Promise.all(destinations.map(
/*#__PURE__*/
function () {
var _ref = _asyncToGenerator(function* (destination) {
if (destination instanceof Function) {
yield destination(defaultCustomPropertiesToJSON(customProperties));
} else {
// read the destination as an object
const opts = destination === Object(destination) ? destination : {
to: String(destination)
}; // transformer for Custom Properties into a JSON-compatible object
const toJSON = opts.toJSON || defaultCustomPropertiesToJSON;
if ('customProperties' in opts) {
// write directly to an object as customProperties
opts.customProperties = toJSON(customProperties);
} else if ('custom-properties' in opts) {
// write directly to an object as custom-properties
opts['custom-properties'] = toJSON(customProperties);
} else {
// destination pathname
const to = String(opts.to || ''); // type of file being written to
const type = (opts.type || path.extname(opts.to).slice(1)).toLowerCase(); // transformed Custom Properties
const customPropertiesJSON = toJSON(customProperties);
if (type === 'css') {
yield writeCustomPropertiesToCssFile(to, customPropertiesJSON);
}
if (type === 'js') {
yield writeCustomPropertiesToCjsFile(to, customPropertiesJSON);
}
if (type === 'json') {
yield writeCustomPropertiesToJsonFile(to, customPropertiesJSON);
}
if (type === 'mjs') {
yield writeCustomPropertiesToMjsFile(to, customPropertiesJSON);
}
}
}
});
return function (_x9) {
return _ref.apply(this, arguments);
};
}()));
}
/* Helper utilities
/* ========================================================================== */
const defaultCustomPropertiesToJSON = customProperties => {
return Object.keys(customProperties).reduce((customPropertiesJSON, key) => {
customPropertiesJSON[key] = String(customProperties[key]);
return customPropertiesJSON;
}, {});
};
const writeFile = (to, text) => new Promise((resolve, reject) => {
fs.writeFile(to, text, error => {
if (error) {
reject(error);
} else {
resolve();
}
});
});
const escapeForJS = string => string.replace(/\\([\s\S])|(')/g, '\\$1$2').replace(/\n/g, '\\n').replace(/\r/g, '\\r');
var index = postcss.plugin('postcss-custom-properties', opts => {
// whether to preserve custom selectors and rules using them
const preserve = 'preserve' in Object(opts) ? Boolean(opts.preserve) : true; // sources to import custom selectors from
const importFrom = [].concat(Object(opts).importFrom || []); // destinations to export custom selectors to
const exportTo = [].concat(Object(opts).exportTo || []); // promise any custom selectors are imported
const customPropertiesPromise = getCustomPropertiesFromImports(importFrom); // synchronous transform
const syncTransform = root => {
const customProperties = getCustomPropertiesFromRoot(root, {
preserve
});
transformProperties(root, customProperties, {
preserve
});
}; // asynchronous transform
const asyncTransform =
/*#__PURE__*/
function () {
var _ref = _asyncToGenerator(function* (root) {
const customProperties = Object.assign({}, (yield customPropertiesPromise), getCustomPropertiesFromRoot(root, {
preserve
}));
yield writeCustomPropertiesToExports(customProperties, exportTo);
transformProperties(root, customProperties, {
preserve
});
});
return function asyncTransform(_x) {
return _ref.apply(this, arguments);
};
}(); // whether to return synchronous function if no asynchronous operations are requested
const canReturnSyncFunction = importFrom.length === 0 && exportTo.length === 0;
return canReturnSyncFunction ? syncTransform : asyncTransform;
});
module.exports = index;
//# sourceMappingURL=index.cjs.js.map