hw-react-1/node_modules/postcss-env-function/index.cjs.js

'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var parser = _interopDefault(require('postcss-values-parser'));
var fs = _interopDefault(require('fs'));
var path = _interopDefault(require('path'));
var postcss = _interopDefault(require('postcss'));

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);
    });
  };
}

const dashedMatch = /^--/; // returns the value of a css function as a string

var getFnValue = (node => {
  const value = String(node.nodes.slice(1, -1));
  return dashedMatch.test(value) ? value : undefined;
});

var updateEnvValue = ((node, variables) => {
  // get the value of a css function as a string
  const value = getFnValue(node);

  if (typeof value === 'string' && value in variables) {
    node.replaceWith(...asClonedArrayWithBeforeSpacing(variables[value], node.raws.before));
  }
}); // 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;
};

// returns whether a node is a css env() function
var isEnvFunc = (node => node && node.type === 'func' && node.value === 'env');

function walk(node, fn) {
  node.nodes.slice(0).forEach(childNode => {
    if (childNode.nodes) {
      walk(childNode, fn);
    }

    if (isEnvFunc(childNode)) {
      fn(childNode);
    }
  });
}

var getReplacedValue = ((originalValue, variables) => {
  // get the ast of the original value
  const ast = parser(originalValue).parse(); // walk all of the css env() functions

  walk(ast, node => {
    // update the environment value for the css env() function
    updateEnvValue(node, variables);
  }); // return the stringified ast

  return String(ast);
});

// returns whether a node is an at-rule
var isAtrule = (node => node && node.type === 'atrule');

// returns whether a node is a declaration
var isDecl = (node => node && node.type === 'decl');

var getSupportedValue = (node => isAtrule(node) && node.params || isDecl(node) && node.value);

function setSupportedValue (node, value) {
  if (isAtrule(node)) {
    node.params = value;
  }

  if (isDecl(node)) {
    node.value = value;
  }
}

/* Import Custom Properties from Object
/* ========================================================================== */

function importEnvironmentVariablesFromObject(object) {
  const environmentVariables = Object.assign({}, Object(object).environmentVariables || Object(object)['environment-variables']);

  for (const key in environmentVariables) {
    environmentVariables[key] = parser(environmentVariables[key]).parse().nodes;
  }

  return environmentVariables;
}
/* Import Custom Properties from JSON file
/* ========================================================================== */


function importEnvironmentVariablesFromJSONFile(_x) {
  return _importEnvironmentVariablesFromJSONFile.apply(this, arguments);
}
/* Import Custom Properties from JS file
/* ========================================================================== */


function _importEnvironmentVariablesFromJSONFile() {
  _importEnvironmentVariablesFromJSONFile = _asyncToGenerator(function* (from) {
    const object = yield readJSON(path.resolve(from));
    return importEnvironmentVariablesFromObject(object);
  });
  return _importEnvironmentVariablesFromJSONFile.apply(this, arguments);
}

function importEnvironmentVariablesFromJSFile(_x2) {
  return _importEnvironmentVariablesFromJSFile.apply(this, arguments);
}
/* Import Custom Properties from Sources
/* ========================================================================== */


function _importEnvironmentVariablesFromJSFile() {
  _importEnvironmentVariablesFromJSFile = _asyncToGenerator(function* (from) {
    const object = yield Promise.resolve(require(path.resolve(from)));
    return importEnvironmentVariablesFromObject(object);
  });
  return _importEnvironmentVariablesFromJSFile.apply(this, arguments);
}

function importEnvironmentVariablesFromSources(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.environmentVariables || opts['environment-variables']) {
      return opts;
    } // source pathname


    const from = 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* (environmentVariables, source) {
      const _ref2 = yield source,
            type = _ref2.type,
            from = _ref2.from;

      if (type === 'js') {
        return Object.assign(environmentVariables, (yield importEnvironmentVariablesFromJSFile(from)));
      }

      if (type === 'json') {
        return Object.assign(environmentVariables, (yield importEnvironmentVariablesFromJSONFile(from)));
      }

      return Object.assign(environmentVariables, importEnvironmentVariablesFromObject((yield source)));
    });

    return function (_x3, _x4) {
      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(_x5) {
    return _ref3.apply(this, arguments);
  };
}();

var index = postcss.plugin('postcss-env-fn', opts => {
  // sources to import environment variables from
  const importFrom = [].concat(Object(opts).importFrom || []); // promise any environment variables are imported

  const environmentVariablesPromise = importEnvironmentVariablesFromSources(importFrom);
  return (
    /*#__PURE__*/
    function () {
      var _ref = _asyncToGenerator(function* (root) {
        const environmentVariables = yield environmentVariablesPromise;
        root.walk(node => {
          const supportedValue = getSupportedValue(node);

          if (supportedValue) {
            const replacedValue = getReplacedValue(supportedValue, environmentVariables);

            if (replacedValue !== supportedValue) {
              setSupportedValue(node, replacedValue);
            }
          }
        });
      });

      return function (_x) {
        return _ref.apply(this, arguments);
      };
    }()
  );
});

module.exports = index;
//# sourceMappingURL=index.cjs.js.map