@querycap-ui/core.macro
Version:
369 lines (288 loc) • 12.9 kB
JavaScript
;
Object.defineProperty(exports, '__esModule', { value: true });
var _findInstanceProperty = require('@babel/runtime-corejs3/core-js/instance/find');
var _startsWithInstanceProperty = require('@babel/runtime-corejs3/core-js/instance/starts-with');
var _mapInstanceProperty = require('@babel/runtime-corejs3/core-js/instance/map');
var _Object$keys = require('@babel/runtime-corejs3/core-js/object/keys');
var _forEachInstanceProperty = require('@babel/runtime-corejs3/core-js/instance/for-each');
var _Object$values = require('@babel/runtime-corejs3/core-js/object/values');
var _reverseInstanceProperty = require('@babel/runtime-corejs3/core-js/instance/reverse');
var generate = require('@babel/generator');
var helperModuleImports = require('@babel/helper-module-imports');
var t = require('@babel/types');
var serialize = require('@emotion/serialize');
var cssAliases = require('@querycap-ui/css-aliases');
var babelPluginMacros = require('babel-plugin-macros');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
function _interopNamespace(e) {
if (e && e.__esModule) return e;
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n["default"] = e;
return Object.freeze(n);
}
var _findInstanceProperty__default = /*#__PURE__*/_interopDefaultLegacy(_findInstanceProperty);
var _startsWithInstanceProperty__default = /*#__PURE__*/_interopDefaultLegacy(_startsWithInstanceProperty);
var _mapInstanceProperty__default = /*#__PURE__*/_interopDefaultLegacy(_mapInstanceProperty);
var _Object$keys__default = /*#__PURE__*/_interopDefaultLegacy(_Object$keys);
var _forEachInstanceProperty__default = /*#__PURE__*/_interopDefaultLegacy(_forEachInstanceProperty);
var _Object$values__default = /*#__PURE__*/_interopDefaultLegacy(_Object$values);
var _reverseInstanceProperty__default = /*#__PURE__*/_interopDefaultLegacy(_reverseInstanceProperty);
var generate__default = /*#__PURE__*/_interopDefaultLegacy(generate);
var t__namespace = /*#__PURE__*/_interopNamespace(t);
const aliases = cssAliases.aliases;
const createImporter = (path, source) => {
const exports = {};
const program = path.isProgram() ? path : path.findParent(p => p.isProgram());
return method => {
if (!exports[method]) {
var _context;
const importDeclaration = /*#__PURE__*/_findInstanceProperty__default["default"](_context = /*#__PURE__*/program.get("body")).call(_context, p => p.isImportDeclaration() && p.node.source.value === source);
if (importDeclaration) {
var _context2;
const importSpecifier = /*#__PURE__*/_findInstanceProperty__default["default"](_context2 = /*#__PURE__*/importDeclaration.get("specifiers")).call(_context2, n => n.isImportSpecifier() && t.isIdentifier(n.node.imported) && n.node.imported.name === method);
if (importSpecifier && importSpecifier.isImportSpecifier()) {
exports[method] = importSpecifier.node.local;
}
}
if (!exports[method]) {
exports[method] = method === "default" ? helperModuleImports.addDefault(path, source) : helperModuleImports.addNamed(path, method, source);
}
}
return exports[method];
};
};
const generatedPrefix = "__macro_generated_";
const isGenerated = id => _startsWithInstanceProperty__default["default"](id).call(id, generatedPrefix);
const createScanner = program => {
const querycapUICoreImport = /*#__PURE__*/createImporter(program, "@querycap-ui/core");
const objectExpression = o => {
var _context3;
return t__namespace.objectExpression( /*#__PURE__*/_mapInstanceProperty__default["default"](_context3 = /*#__PURE__*/_Object$keys__default["default"](o)).call(_context3, k => {
const key = /^[A-Za-z_$][A-Za-z0-9_$]+$/.test(k) ? t__namespace.identifier(k) : t__namespace.stringLiteral(k);
return t__namespace.objectProperty(key, o[k]);
}));
};
const callExpression = (callee, ...args) => {
return t__namespace.callExpression(callee, args);
};
const themeNeedMark = "__THEME_NEED__";
const hasThemeNeed = node => {
var _context4;
return node.leadingComments && _findInstanceProperty__default["default"](_context4 = node.leadingComments).call(_context4, c => c.value == themeNeedMark);
};
const markThemeNeed = node => {
if (hasThemeNeed(node)) {
return node;
}
return t__namespace.addComment(node, "leading", themeNeedMark);
};
const withFromTheme = arg => {
return callExpression( /*#__PURE__*/querycapUICoreImport("fromTheme"), arg);
};
const asThemeGetter = returnExpr => t__namespace.arrowFunctionExpression([/*#__PURE__*/t__namespace.identifier(generatedPrefix + "t")], returnExpr);
const createHoisting = () => {
let styleIdx = 0;
return (nodePath, expr) => {
const ident = /*#__PURE__*/t__namespace.identifier(`${generatedPrefix}ref_${styleIdx}`);
const decl = /*#__PURE__*/t__namespace.variableDeclaration("var", [/*#__PURE__*/t__namespace.variableDeclarator(ident, expr)]);
const ownerDecl = /*#__PURE__*/nodePath.findParent(p => p.parentPath.isProgram());
const inserted = ownerDecl.insertBefore([decl])[0];
styleIdx++;
return inserted && inserted.get("declarations")[0];
};
};
const hoistAsVariable = /*#__PURE__*/createHoisting();
const hoistStaticCSS = (nodePath, o) => {
var _generate;
const cssObject = (_generate = /*#__PURE__*/generate__default["default"]( /*#__PURE__*/objectExpression(o))) === null || _generate === void 0 ? void 0 : _generate.code;
const res = /*#__PURE__*/serialize.serializeStyles([/*#__PURE__*/eval(`(${cssObject})`)], {});
const variableDeclarator = /*#__PURE__*/hoistAsVariable(nodePath, /*#__PURE__*/objectExpression({
name: /*#__PURE__*/t__namespace.stringLiteral(res.name),
styles: /*#__PURE__*/t__namespace.stringLiteral(res.styles)
}));
return variableDeclarator.node.id;
};
const createCollector = (nodePath, selectors) => {
const parts = [];
let needTheme = false;
let hasStatic = false;
let hasThemeGetter = false;
let cssStaticProps = {};
let cssThemeGetterProps = {};
const swap = () => {
if (hasStatic) {
parts.push( /*#__PURE__*/hoistStaticCSS(nodePath, cssStaticProps));
}
if (hasThemeGetter) {
parts.push( /*#__PURE__*/objectExpression(cssThemeGetterProps));
}
cssStaticProps = {};
cssThemeGetterProps = {};
hasStatic = false;
hasThemeGetter = false;
};
const callWithTheme = arg => {
needTheme = true;
return callExpression(arg, /*#__PURE__*/t__namespace.identifier(generatedPrefix + "t"));
};
const createCSSValues = blocks => {
const toObject = () => {
const v = blocks.length === 1 ? blocks[0] : t__namespace.arrayExpression(blocks);
if (selectors.length > 0) {
const key = /*#__PURE__*/callExpression( /*#__PURE__*/querycapUICoreImport("selectKeys"), ...selectors);
return t__namespace.objectExpression([/*#__PURE__*/t__namespace.objectProperty(key, v, true)]);
}
return v;
};
if (needTheme) {
return markThemeNeed( /*#__PURE__*/asThemeGetter( /*#__PURE__*/toObject()));
}
return toObject();
};
return {
addWith: path => {
swap();
if (hasThemeNeed(path.node) || path.isIdentifier()) {
parts.push( /*#__PURE__*/callWithTheme( /*#__PURE__*/withFromTheme(path.node)));
} else {
parts.push(path.node);
}
},
addStatic: (key, path) => {
const add = k => cssStaticProps[k] = path.node;
if (aliases[key]) {
var _context5;
_forEachInstanceProperty__default["default"](_context5 = aliases[key]).call(_context5, add);
} else {
add(key);
}
hasStatic = true;
},
addThemeGetter: (key, path) => {
const add = k => cssThemeGetterProps[k] = /*#__PURE__*/callWithTheme( /*#__PURE__*/withFromTheme(path.node));
if (aliases[key]) {
var _context6;
_forEachInstanceProperty__default["default"](_context6 = aliases[key]).call(_context6, add);
} else {
add(key);
}
hasThemeGetter = true;
},
emitTo: chainRoot => {
swap();
const result = /*#__PURE__*/createCSSValues(parts);
if (t__namespace.isIdentifier(result)) {
chainRoot.replaceWith(result);
return;
}
chainRoot.replaceWith( /*#__PURE__*/withFromTheme(result));
const createFunctionIfNeed = () => {
const paramSet = {};
chainRoot.traverse({
Function: {
enter(nodePath, state) {
state.funcNodePath = nodePath;
},
exit(_, state) {
delete state.funcNodePath;
}
},
Identifier(nodePath, state) {
if (!nodePath.isReferencedIdentifier()) {
return;
}
if (program.scope.hasBinding(nodePath.node.name)) {
return;
}
if (isGenerated(nodePath.node.name)) {
return;
}
if (state.funcNodePath && state.funcNodePath.scope.hasOwnBinding(nodePath.node.name)) {
return;
}
paramSet[nodePath.node.name] = nodePath.node;
}
}, {});
const params = /*#__PURE__*/_Object$values__default["default"](paramSet);
if (params.length === 0) {
const variableDeclarator = /*#__PURE__*/hoistAsVariable(nodePath, result);
return t__namespace.clone(variableDeclarator.node.id);
}
const variableDeclarator = /*#__PURE__*/hoistAsVariable(nodePath, /*#__PURE__*/t__namespace.arrowFunctionExpression(params, result));
return callExpression(variableDeclarator.node.id, ...params);
};
if (needTheme) {
chainRoot.replaceWith( /*#__PURE__*/markThemeNeed( /*#__PURE__*/createFunctionIfNeed()));
if (chainRoot.parentPath.isExpression()) {
markThemeNeed(chainRoot.parentPath.node);
}
} else {
chainRoot.replaceWith( /*#__PURE__*/createFunctionIfNeed());
}
}
};
};
return {
scan: path => {
const collector = /*#__PURE__*/createCollector(path, path.node.arguments);
const resolveCallChain = path => {
const memberExpression = path.parentPath;
if (memberExpression.isMemberExpression()) {
if (memberExpression.parentPath.isCallExpression()) {
const arg = memberExpression.parentPath.get("arguments")[0];
if (arg) {
if (memberExpression.node.property.name === "with") {
collector.addWith(arg);
} else {
collector[t__namespace.isLiteral(arg) && !t__namespace.isTemplateLiteral(arg) ? "addStatic" : "addThemeGetter"](memberExpression.node.property.name, arg);
}
} // resolve chain
if (memberExpression.parentPath.isCallExpression()) {
return resolveCallChain(memberExpression.parentPath);
}
}
}
return path;
};
const chainRoot = /*#__PURE__*/resolveCallChain(path);
if (chainRoot) {
collector.emitTo(chainRoot);
}
}
};
};
var index = babelPluginMacros.createMacro(({
references
}) => {
var _context7;
_forEachInstanceProperty__default["default"](_context7 = /*#__PURE__*/_Object$keys__default["default"](references)).call(_context7, k => {
if (references[k].length > 0) {
if (k === "select") {
var _context8, _context9;
const program = /*#__PURE__*/references[k][0].findParent(p => p.isProgram());
const scanner = /*#__PURE__*/createScanner(program);
_forEachInstanceProperty__default["default"](_context8 = /*#__PURE__*/_reverseInstanceProperty__default["default"](_context9 = references[k]).call(_context9)).call(_context8, p => {
return p.parentPath.isCallExpression() && scanner.scan(p.parentPath);
});
} else {
var _context10;
const querycapUICoreImport = /*#__PURE__*/createImporter(references[k][0], "@querycap-ui/core");
_forEachInstanceProperty__default["default"](_context10 = references[k]).call(_context10, p => {
p.node.name = querycapUICoreImport(k).name;
});
}
}
});
});
exports["default"] = index;