flask-urls.macro/lib/flask-urls.macro.js

Provides a babel macro for building Flask URLs client-side.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _babelPluginMacros = require("babel-plugin-macros");

var _helperModuleImports = require("@babel/helper-module-imports");

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

const defaultConfig = {
  builder: 'flask-urls',
  urlMap: {},
  mock: false,
  basePath: ''
};

const macro = (_ref) => {
  let {
    babel: {
      types: t,
      template
    },
    config: localConfig,
    references,
    state
  } = _ref;

  const config = _objectSpread({}, defaultConfig, {}, localConfig);

  if (!references.default) {
    throw new _babelPluginMacros.MacroError('flask-urls.macro requires a default import');
  } else if (Object.keys(references).length !== 1) {
    throw new _babelPluginMacros.MacroError('flask-urls.macro only supports a default import');
  } else if (references.default.length === 0) {
    throw new _babelPluginMacros.MacroError('flask-urls.macro is imported but not used');
  }

  const buildFunc = template.expression('FUNC.bind(null, RULE, BASE)');
  const buildFuncMock = template.expression('FUNC.bind(null, ENDPOINT)');
  let builderFuncId;
  references.default.forEach((_ref2) => {
    let {
      parentPath
    } = _ref2;

    if (parentPath.type !== 'TaggedTemplateExpression') {
      throw new _babelPluginMacros.MacroError('flask-urls.macro only supports tagged template expressions');
    }

    const quasi = parentPath.node.quasi;

    if (quasi.expressions.length) {
      throw new _babelPluginMacros.MacroError('flask-url.macro cannot contain expressions');
    }

    const endpoint = quasi.quasis[0].value.cooked;

    if (builderFuncId) {
      builderFuncId = t.cloneDeep(builderFuncId);
    }

    let replacement;

    if (config.mock) {
      if (!builderFuncId) {
        builderFuncId = (0, _helperModuleImports.addNamed)(state.file.path, 'mockFlaskURL', config.builder, {
          nameHint: 'mockFlaskURL'
        });
      }

      replacement = buildFuncMock({
        FUNC: builderFuncId,
        ENDPOINT: t.stringLiteral(endpoint)
      });
    } else {
      const data = config.urlMap[endpoint];

      if (!data) {
        throw new _babelPluginMacros.MacroError('flask-url.macro must reference a valid flask endpoint');
      } // generate import


      if (!builderFuncId) {
        builderFuncId = (0, _helperModuleImports.addDefault)(state.file.path, config.builder, {
          nameHint: 'buildFlaskURL'
        });
      }

      replacement = buildFunc({
        FUNC: builderFuncId,
        RULE: t.valueToNode(data),
        BASE: t.stringLiteral(config.basePath)
      });
    } // replace the tagged template expression with the builder function


    parentPath.replaceWith(replacement);
  });
};

var _default = (0, _babelPluginMacros.createMacro)(macro, {
  configName: 'flaskURLs'
});

exports.default = _default;