weapp-tailwindcss/dist/chunk-QJTJC5UT.mjs

把 tailwindcss 原子化样式思想，带给小程序开发者们! bring tailwindcss to miniprogram developers!

import {
  resolveTailwindcssImport
} from "./chunk-3SKEY32E.mjs";
import {
  pluginName
} from "./chunk-4Z6MHSEO.mjs";

// src/shared/mpx.ts
import path2 from "path";

// src/shared/tailwindcss-css-redirect.ts
import Module from "module";
import path from "path";
var moduleWithMutableResolve = Module;
var patched = /* @__PURE__ */ new WeakSet();
function installTailwindcssCssRedirect(pkgDir) {
  const target = path.join(pkgDir, "index.css");
  const original = moduleWithMutableResolve._resolveFilename;
  if (patched.has(original)) {
    return;
  }
  const replacements = /* @__PURE__ */ new Set(["tailwindcss", "tailwindcss$"]);
  const resolveTailwindcssCss = (request, parent, isMain, options) => {
    if (replacements.has(request)) {
      return target;
    }
    if (request.startsWith("tailwindcss/")) {
      return path.join(pkgDir, request.slice("tailwindcss/".length));
    }
    return original(request, parent, isMain, options);
  };
  moduleWithMutableResolve._resolveFilename = resolveTailwindcssCss;
  patched.add(moduleWithMutableResolve._resolveFilename);
}

// src/shared/mpx.ts
var MPX_STYLE_RESOURCE_QUERY_RE = /(?:^|[?&])type=styles(?:&|$)/;
function isMpxStyleResourceQuery(query) {
  if (typeof query !== "string") {
    return false;
  }
  return MPX_STYLE_RESOURCE_QUERY_RE.test(query);
}
function isMpx(appType) {
  return appType === "mpx";
}
function getTailwindcssCssEntry(pkgDir) {
  return path2.join(pkgDir, "index.css");
}
function ensureMpxTailwindcssAliases(compiler, pkgDir) {
  const tailwindcssCssEntry = getTailwindcssCssEntry(pkgDir);
  compiler.options = compiler.options || {};
  compiler.options.resolve = compiler.options.resolve || {};
  const alias = compiler.options.resolve.alias ?? {};
  if (Array.isArray(alias)) {
    alias.push(
      { name: "tailwindcss", alias: tailwindcssCssEntry },
      { name: "tailwindcss$", alias: tailwindcssCssEntry }
    );
  } else {
    compiler.options.resolve.alias = alias;
    alias.tailwindcss = tailwindcssCssEntry;
    alias.tailwindcss$ = tailwindcssCssEntry;
  }
  return tailwindcssCssEntry;
}
function patchMpxLoaderResolve(loaderContext, pkgDir, enabled) {
  if (!enabled || typeof loaderContext.resolve !== "function") {
    return;
  }
  const originalResolve = loaderContext.resolve;
  if (originalResolve.__weappTwPatched) {
    return;
  }
  const tailwindcssCssEntry = getTailwindcssCssEntry(pkgDir);
  const wrappedResolve = function(context, request, callback) {
    if (request === "tailwindcss" || request === "tailwindcss$") {
      return callback(null, tailwindcssCssEntry);
    }
    if (request?.startsWith("tailwindcss/")) {
      return callback(null, path2.join(pkgDir, request.slice("tailwindcss/".length)));
    }
    return originalResolve.call(this, context, request, callback);
  };
  wrappedResolve.__weappTwPatched = true;
  loaderContext.resolve = wrappedResolve;
}
function setupMpxTailwindcssRedirect(pkgDir, enabled) {
  if (enabled) {
    installTailwindcssCssRedirect(pkgDir);
  }
}
function injectMpxCssRewritePreRules(compiler, loader, loaderOptions) {
  var _a;
  if (!loader) {
    return;
  }
  const moduleOptions = (_a = compiler.options).module ?? (_a.module = { rules: [] });
  moduleOptions.rules = moduleOptions.rules || [];
  const createRule = (match) => ({
    ...match,
    enforce: "pre",
    use: [
      {
        loader,
        options: loaderOptions
      }
    ]
  });
  moduleOptions.rules.unshift(
    createRule({ resourceQuery: (query) => isMpxStyleResourceQuery(query) }),
    createRule({
      test: /\.css$/i,
      resourceQuery: (query) => !isMpxStyleResourceQuery(query)
    })
  );
}

// src/bundlers/webpack/shared/css-imports.ts
var CSS_EXT_RE = /\.(?:css|scss|sass|less|styl|pcss)$/i;
function stripResourceQuery(file) {
  let idx = file.indexOf("?");
  if (idx === -1) {
    idx = file.indexOf("&");
  }
  return idx === -1 ? file : file.slice(0, idx);
}
function rewriteTailwindcssRequestForCss(data, pkgDir, appType) {
  if (!data) {
    return;
  }
  const request = data.request;
  if (!request) {
    return;
  }
  if (request !== "tailwindcss" && request !== "tailwindcss$" && !request.startsWith("tailwindcss/")) {
    return;
  }
  const issuer = data.contextInfo?.issuer;
  if (!issuer) {
    return;
  }
  const normalizedIssuer = stripResourceQuery(issuer);
  if (!CSS_EXT_RE.test(normalizedIssuer)) {
    return;
  }
  const resolved = resolveTailwindcssImport(request, pkgDir, { appType });
  if (!resolved) {
    return;
  }
  data.request = resolved;
}
function applyTailwindcssCssImportRewrite(compiler, options) {
  if (!options.enabled) {
    return;
  }
  compiler.hooks.normalModuleFactory.tap(pluginName, (factory) => {
    factory.hooks.beforeResolve.tap(pluginName, (data) => {
      rewriteTailwindcssRequestForCss(data, options.pkgDir, options.appType);
    });
  });
}

// src/bundlers/webpack/shared/loader-anchors.ts
var MPX_STRIP_CONDITIONAL_LOADER = "@mpxjs/webpack-plugin/lib/style-compiler/strip-conditional-loader";
var MPX_STYLE_COMPILER_LOADER = "@mpxjs/webpack-plugin/lib/style-compiler/index";
var MPX_REWRITE_PRECEDENCE_LOADERS = [
  MPX_STYLE_COMPILER_LOADER,
  MPX_STRIP_CONDITIONAL_LOADER
];
function createFinder(targets) {
  return (entries) => entries.findIndex(
    (entry) => targets.some((target) => entry?.loader?.includes?.(target))
  );
}
function createPrioritizedFinder(targets) {
  return (entries) => {
    for (const target of targets) {
      const idx = entries.findIndex((entry) => entry?.loader?.includes?.(target));
      if (idx !== -1) {
        return idx;
      }
    }
    return -1;
  };
}
function createLoaderAnchorFinders(appType) {
  if (isMpx(appType)) {
    return {
      findRewriteAnchor: createPrioritizedFinder(MPX_REWRITE_PRECEDENCE_LOADERS),
      findClassSetAnchor: createFinder([MPX_STYLE_COMPILER_LOADER])
    };
  }
  const fallbackFinder = createFinder(["postcss-loader"]);
  return {
    findRewriteAnchor: fallbackFinder,
    findClassSetAnchor: fallbackFinder
  };
}

// src/bundlers/webpack/BaseUnifiedPlugin/shared.ts
var MPX_STYLE_RESOURCE_QUERY_RE2 = /(?:\?|&)type=styles\b/;
function getCacheKey(filename) {
  return filename;
}
function stripResourceQuery2(resource) {
  if (typeof resource !== "string") {
    return resource;
  }
  const queryIndex = resource.indexOf("?");
  if (queryIndex !== -1) {
    return resource.slice(0, queryIndex);
  }
  const hashIndex = resource.indexOf("#");
  if (hashIndex !== -1) {
    return resource.slice(0, hashIndex);
  }
  return resource;
}
function isCssLikeModuleResource(resource, cssMatcher, appType) {
  if (typeof resource !== "string") {
    return false;
  }
  const normalizedResource = stripResourceQuery2(resource);
  if (normalizedResource && cssMatcher(normalizedResource)) {
    return true;
  }
  if (appType === "mpx") {
    return MPX_STYLE_RESOURCE_QUERY_RE2.test(resource);
  }
  return false;
}
function hasLoaderEntry(entries, target) {
  if (!target) {
    return false;
  }
  return entries.some((entry) => entry.loader?.includes?.(target));
}

export {
  isMpx,
  ensureMpxTailwindcssAliases,
  patchMpxLoaderResolve,
  setupMpxTailwindcssRedirect,
  injectMpxCssRewritePreRules,
  applyTailwindcssCssImportRewrite,
  createLoaderAnchorFinders,
  getCacheKey,
  isCssLikeModuleResource,
  hasLoaderEntry
};