@cxing/vitejs-plugin-inject-css/dist/vitejs-plugin-inject-css.es.js

A plugin for ViteJs library builds to inject css modules

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __reExport = (target, module2, copyDefault, desc) => {
  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
    for (let key of __getOwnPropNames(module2))
      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
  }
  return target;
};
var __toESM = (module2, isNodeMode) => {
  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
};
var __toCommonJS = /* @__PURE__ */ ((cache) => {
  return (module2, temp) => {
    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
  };
})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);

// src/index.js
var src_exports = {};
__export(src_exports, {
  default: () => libInjectCss
});
var import_fs = __toESM(require("fs"));
var import_path = require("path");
var import_hash_generator = __toESM(require("../node_modules/hash-generator/index.js"));
var minify = require("../node_modules/@node-minify/core/lib/core.js");
var cleanCSS = require("../node_modules/@node-minify/clean-css/lib/clean-css.js");
var fileRegex = /\.module\.(scss|less|css)(\?used)?$/;
var injector = `function styleInject(css, ref) {
  if ( ref === void 0 ) ref = {};
  var insertAt = ref.insertAt;
  if (!css || typeof document === 'undefined') { return; }
  var head = document.head || document.getElementsByTagName('head')[0];
  var style = document.createElement('style');
  style.type = 'text/css';
  if (insertAt === 'top') {
    if (head.firstChild) {
      head.insertBefore(style, head.firstChild);
    } else {
      head.appendChild(style);
    }
  } else {
    head.appendChild(style);
  }
  if (style.styleSheet) {
    style.styleSheet.cssText = css;
  } else {
    style.appendChild(document.createTextNode(css));
  }
}`;
var injectCode = (value) => {
  const codeId = (0, import_hash_generator.default)(5);
  return `const css_${codeId} = "${value}";

styleInject(css_${codeId});

`;
};
var template = `console.warn("__INJECT__")`;
function buildOutput(extracts) {
  const out = [];
  extracts.forEach((value) => {
    out.push(injectCode(value));
  });
  return `
${injector}

${out.join("")}`;
}
var viteConfig;
var css = [];
function libInjectCss() {
  const extracted = /* @__PURE__ */ new Map();
  return {
    name: "lib-inject-css",
    apply: "build",
    configResolved(resolvedConfig) {
      viteConfig = resolvedConfig;
    },
    async transform(code, id) {
      if (fileRegex.test(id)) {
        const minified = await minify({
          compressor: cleanCSS,
          content: code
        });
        extracted.set(id, minified);
        css.push(code);
        return {
          code: ""
        };
      }
      if (id.includes(viteConfig.build.lib.entry)) {
        return {
          code: `${code}
${template}`
        };
      }
      return null;
    },
    async writeBundle(_, bundle) {
      for (const file of Object.entries(bundle)) {
        const { root } = viteConfig;
        const outDir = viteConfig.build.outDir || "dist";
        const fileName = file[0];
        const filePath = (0, import_path.resolve)(root, outDir, fileName);
        try {
          let data = import_fs.default.readFileSync(filePath, {
            encoding: "utf8"
          });
          if (data.includes(template)) {
            data = data.replace(template, buildOutput(extracted));
          }
          import_fs.default.writeFileSync(filePath, data);
        } catch (e) {
          console.error(e);
        }
      }
    }
  };
}
module.exports = __toCommonJS(src_exports);
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {});