All files / transpilers create.js

43.48% Statements 20/46
0% Branches 0/4
20% Functions 1/5
43.48% Lines 20/46

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 782x 2x 2x 2x 2x 2x 2x 2x       2x 2x 2x         2x 2x 2x 2x                                       1x 1x   1x 1x                                                             2x  
const generateClasses = require('../helpers/generate-classes');
const generateStyles = require('../helpers/generate-styles');
const getStyleObjectValue = require('../helpers/get-style-object-value');
const listDynamicKeys = require('../helpers/list-dynamic-keys');
const listFunctionCallKeys = require('../helpers/list-function-call-keys');
const listFunctionCalls = require('../helpers/list-function-calls');
const listReferences = require('../helpers/list-references');
const listStaticKeys = require('../helpers/list-static-keys');
const {
  replaceCreateCall,
  replaceFunctionCalls
} = require('../helpers/mutate-ast');
const normalizeArguments = require('../helpers/normalize-arguments');
const { validateReferences, validateStyleObject } = require('../helpers/validate');
const {
  mapObject,
  mapObjectValues,
  filterObjectKeys
} = require('../utils/helpers');
const { minifyProperty } = require('../utils/styles');
const stripTypeAssertions = require('../helpers/strip-type-assertions');
const flattenAtRules = require('../helpers/flatten-at-rules');
 
function normalizeFunctionCalls(callExpressions, styleNames) {
  const entries = callExpressions.map(id => {
    return [id.parentPath, normalizeArguments(id.parentPath, styleNames)];
  });
  return new Map(entries);
}
 
function minifyProperties(classes) {
  return mapObject(classes, ([key, value]) => {
    const minifiedName = minifyProperty(key);
    const isObject = typeof value === 'object';
    const minifiedValue = isObject ? minifyProperties(value) : value;
 
    return [minifiedName, minifiedValue];
  });
}
 
function transpileCreate(identifier, options) {
  const callExpr = identifier.parentPath.parentPath;
  const objExpr = callExpr.get('arguments.0');
 
  stripTypeAssertions(objExpr);
  validateStyleObject(objExpr);
 
  const styleDefinitions = flattenAtRules(getStyleObjectValue(objExpr));
  const styleClasses = generateClasses(styleDefinitions);
  const references = listReferences(callExpr.parentPath);
 
  validateReferences(references);
 
  const funcCalls = listFunctionCalls(references);
  const styleNames = Object.keys(styleDefinitions);
  const normalizedFuncCalls = normalizeFunctionCalls(funcCalls, styleNames);
 
  const staticKeys = listStaticKeys(callExpr, styleNames);
  const dynamicKeys = listDynamicKeys(references, styleNames);
  const funcCallKeys = listFunctionCallKeys([...normalizedFuncCalls.values()]);
 
  const propKeys = [...staticKeys, ...dynamicKeys];
  const filteredStyleValues = filterObjectKeys(styleClasses, propKeys);
  const allKeys = [...funcCallKeys, ...propKeys];
  const filteredDefinitions = filterObjectKeys(styleDefinitions, allKeys);
 
  const minifiedStyleValues = options.minifyProperties
    ? mapObjectValues(filteredStyleValues, minifyProperties)
    : filteredStyleValues;
 
  replaceCreateCall(callExpr, minifiedStyleValues);
  replaceFunctionCalls(normalizedFuncCalls, styleClasses);
 
  return generateStyles(filteredDefinitions);
}
 
module.exports = { transpileCreate };