unocss-preset-weapp/dist/index.mjs

the unocss preset for wechat miniprogram (uniapp, taro)

import { entriesToCss, toArray, definePreset } from '@unocss/core';
import { extractorArbitraryVariants } from '@unocss/extractor-arbitrary-variants';
import { defaultRules, cacheTransformEscapESelector } from 'unplugin-transform-class/utils';
import { g as globalKeywords } from './shared/unocss-preset-weapp.nctVdKFd.mjs';
export { k as parseColor } from './shared/unocss-preset-weapp.nctVdKFd.mjs';
import { j as variants } from './shared/unocss-preset-weapp.BtDZpLZ0.mjs';
import { r as rules } from './shared/unocss-preset-weapp.BSEwpZC6.mjs';
import { t as theme } from './shared/unocss-preset-weapp.D_fVMJDf.mjs';
export { colors } from './colors.mjs';
import '@unocss/rule-utils';
import './shared/unocss-preset-weapp.B35SUqN_.mjs';
import './shared/unocss-preset-weapp.BtJbtgFk.mjs';

const wxPrefix = ["page,root-portal-content,::before,::after"];
const taroPrefix = ["*,::before,::after"];
const uniappPrefix = ["uni-page-body,::before,::after"];
function preflights(options) {
  if (options.preflight) {
    return [
      {
        layer: "preflights",
        getCSS({ theme, generator }) {
          if (theme.preflightBase) {
            let entries = Object.entries(theme.preflightBase);
            if (options.preflight === "on-demand") {
              const keys = new Set(Array.from(generator.activatedRules).map((r) => r[2]?.custom?.preflightKeys).filter(Boolean).flat());
              entries = entries.filter(([k]) => keys.has(k));
            }
            if (entries.length > 0) {
              let css = entriesToCss(entries);
              if (options.variablePrefix !== "un-") {
                css = css.replace(/--un-/g, `--${options.variablePrefix}`);
              }
              let preflightRoot = theme.preflightRoot;
              if (!preflightRoot) {
                if (options.isH5)
                  preflightRoot = options.platform === "uniapp" ? uniappPrefix : taroPrefix;
                else
                  preflightRoot = wxPrefix;
              }
              const roots = toArray(preflightRoot);
              return roots.map((root) => `${root}{${css}}`).join("");
            }
          }
        }
      }
    ];
  }
}

function taroPxToRpx(size, designWidth, deviceRatio) {
  if (!(designWidth in deviceRatio))
    throw new Error(`deviceRatio \u914D\u7F6E\u4E2D\u4E0D\u5B58\u5728 ${designWidth} \u7684\u8BBE\u7F6E\uFF01`);
  return `${Number.parseInt(size, 10) * deviceRatio[designWidth]}rpx`;
}
function taroRpxToPx(size, designWidth, deviceRatio) {
  if (!(designWidth in deviceRatio))
    throw new Error(`deviceRatio \u914D\u7F6E\u4E2D\u4E0D\u5B58\u5728 ${designWidth} \u7684\u8BBE\u7F6E\uFF01`);
  return Number.parseInt(size, 10) / deviceRatio[designWidth];
}
function taroPxToRemW4(size, designWidth) {
  return `${Math.ceil(Number.parseInt(size, 10) / 40 * 640 / designWidth * 1e5) / 1e5}rem`;
}
function taroPxToRemW5(size, designWidth, deviceRatio) {
  const baseFontSize = 20;
  const unitPrecision = 5;
  const rootValue = baseFontSize / deviceRatio[designWidth] * 2;
  const pixels = Number.parseFloat(size);
  return `${toFixed(pixels / rootValue, unitPrecision)}rem`;
}
function toFixed(number, precision) {
  const multiplier = 10 ** (precision + 1);
  const wholeNumber = Math.floor(number * multiplier);
  return Math.round(wholeNumber / 10) * 10 / multiplier;
}
function taroH5CssRemTransform(css, taroWebpack, designWidth, deviceRatio) {
  cssRpxTransform(css, rpxOrPxRE, (value) => {
    const size = value.endsWith("rpx") ? taroRpxToPx(value.slice(0, -3), designWidth, deviceRatio) : value.slice(0, -2);
    return taroWebpack === "webpack4" ? taroPxToRemW4(size, designWidth) : taroPxToRemW5(size, designWidth, deviceRatio);
  });
}
function taroCssPxTransform(css, designWidth, deviceRatio) {
  cssRpxTransform(css, pxRE, (value) => {
    return taroPxToRpx(value.slice(0, -2), designWidth, deviceRatio);
  });
}

function uniAppRpxTransform(size) {
  return `%?${size}?%`;
}
function uniAppVue2CssRpxTransform(css) {
  cssRpxTransform(css, rpxRE, (value) => {
    return uniAppRpxTransform(value.slice(0, -3));
  });
}

const pxRE = /-?[.\d]+px/g;
const rpxRE = /-?[.\d]+rpx/g;
const rpxOrPxRE = /-?[.\d]+r?px/g;
function cssRpxTransform(css, regex, transform) {
  css.entries.forEach((i) => {
    let value = i[1];
    if (value && typeof value === "string") {
      const matchs = Array.from(value.matchAll(regex));
      if (matchs.length !== 0) {
        matchs.forEach((m) => {
          const size = m[0];
          value = value.replace(size, transform(size));
        });
        i[1] = value;
      }
    }
  });
}

const shorthands = {
  position: [
    "relative",
    "absolute",
    "fixed",
    "sticky",
    "static"
  ],
  globalKeyword: globalKeywords
};

const presetWeapp = definePreset((options = {}) => {
  options.dark = options.dark ?? "class";
  options.attributifyPseudo = options.attributifyPseudo ?? false;
  options.preflight = options.preflight ?? true;
  options.variablePrefix = options.variablePrefix ?? "un-";
  options.transform = options.transform ?? true;
  options.isH5 = options.isH5 ?? false;
  options.designWidth = options.designWidth ?? 750;
  options.deviceRatio = options.deviceRatio ?? {
    640: 2.34 / 2,
    750: 1,
    828: 1.81 / 2
  };
  options.platform = options.platform ?? "uniapp";
  options.taroWebpack = options.taroWebpack ?? "webpack4";
  options.transformRules = options.transformRules ?? defaultRules;
  options.whRpx = options.whRpx ?? true;
  return {
    name: "unocss-preset-weapp",
    theme: {
      ...theme,
      transformRules: options.transformRules,
      whRpx: options.whRpx
    },
    rules,
    variants: variants(options),
    options,
    postprocess(css) {
      if (options.transform)
        css.selector = cacheTransformEscapESelector(css.selector, options.transformRules);
      if (options.variablePrefix !== "un-")
        VarPrefixPostprocessor(options.variablePrefix, css);
      if (options.platform === "taro") {
        const { taroWebpack, designWidth, deviceRatio } = options;
        if (options.isH5) {
          taroH5CssRemTransform(css, taroWebpack, designWidth, deviceRatio);
        } else {
          taroCssPxTransform(css, designWidth, deviceRatio);
        }
      }
      if (options.platform === "uniapp" && options.isH5)
        uniAppVue2CssRpxTransform(css);
    },
    preflights: preflights(options),
    prefix: options.prefix,
    extractorDefault: options.arbitraryVariants === false ? void 0 : extractorArbitraryVariants(),
    autocomplete: {
      shorthands
    }
  };
});
function VarPrefixPostprocessor(prefix, obj) {
  obj.entries.forEach((i) => {
    i[0] = i[0].replace(/^--un-/, `--${prefix}`);
    if (typeof i[1] === "string")
      i[1] = i[1].replace(/var\(--un-/g, `var(--${prefix}`);
  });
}

export { presetWeapp as default, presetWeapp, theme };