@vuesax-alpha/auto-import-resolver/dist/index.cjs

On-demand components auto importing for Vuesax Alpha.

"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));

// src/resolver.ts
var _localpkg = require('local-pkg');
async function getPkgVersion(pkgName, defaultVersion) {
  var _a;
  try {
    const isExist = _localpkg.isPackageExists.call(void 0, pkgName);
    if (isExist) {
      const pkg = await _localpkg.getPackageInfo.call(void 0, pkgName);
      return (_a = pkg == null ? void 0 : pkg.version) != null ? _a : defaultVersion;
    } else {
      return defaultVersion;
    }
  } catch (err) {
    console.error(err);
    return defaultVersion;
  }
}
function kebabCase(key) {
  const result = key.replace(/([A-Z])/g, " $1").trim();
  return result.split(" ").join("-").toLowerCase();
}
function getSideEffects(dirName, options) {
  const { importStyle, ssr } = options;
  const themeFolder = "vuesax-alpha/theme-chalk";
  const esComponentsFolder = "vuesax-alpha/es/components";
  if (importStyle === "sass") {
    return ssr ? `${themeFolder}/src/${dirName}.scss` : `${esComponentsFolder}/${dirName}/style/index`;
  } else if (importStyle === true || importStyle === "css") {
    return ssr ? `${themeFolder}/vs-${dirName}.css` : `${esComponentsFolder}/${dirName}/style/css`;
  }
}
function resolveComponent(name, options) {
  if (options.exclude && name.match(options.exclude))
    return;
  if (!name.match(/^Vs[A-Z]/))
    return;
  const partialName = kebabCase(name.slice(2));
  const { ssr } = options;
  return {
    name,
    from: `vuesax-alpha/${ssr ? "lib" : "es"}`,
    sideEffects: getSideEffects(partialName, options)
  };
}
function resolveDirective(name, options) {
  if (!options.directives)
    return;
  const directives = {
    // Loading: { importName: 'VsLoadingDirective', styleName: 'loading' },
    // InfiniteScroll: {
    //   importName: 'VsInfiniteScroll',
    //   styleName: 'infinite-scroll',
    // },
  };
  const directive = directives[name];
  if (!directive)
    return;
  const { ssr } = options;
  return {
    name: directive.importName,
    from: `vuesax-alpha/${ssr ? "lib" : "es"}`,
    sideEffects: getSideEffects(directive.styleName, options)
  };
}
function VuesaxAlphaResolver(options = {}) {
  let optionsResolved;
  async function resolveOptions() {
    if (optionsResolved)
      return optionsResolved;
    optionsResolved = __spreadValues({
      ssr: false,
      version: await getPkgVersion("vuesax-alpha", "0.0.1"),
      importStyle: "css",
      directives: true,
      exclude: void 0,
      noStylesComponents: options.noStylesComponents || []
    }, options);
    return optionsResolved;
  }
  return [
    {
      type: "component",
      resolve: async (name) => {
        const options2 = await resolveOptions();
        if ([...options2.noStylesComponents].includes(name))
          return resolveComponent(name, __spreadProps(__spreadValues({}, options2), { importStyle: false }));
        else
          return resolveComponent(name, options2);
      }
    },
    {
      type: "directive",
      resolve: async (name) => {
        return resolveDirective(name, await resolveOptions());
      }
    }
  ];
}


exports.VuesaxAlphaResolver = VuesaxAlphaResolver;