weapp-tailwindcss 3.3.7 → 3.4.0-alpha.0

package/dist/chunk-257YPDSI.mjs

@@ -0,0 +1,173 @@
+import {
+  createDebug
+} from "./chunk-75EWCRQW.mjs";
+import {
+  getOptions
+} from "./chunk-PC4B5JJB.mjs";
+import {
+  getGroupedEntries
+} from "./chunk-GUE4UCRJ.mjs";
+import {
+  vitePluginName
+} from "./chunk-IOYI6MSW.mjs";
+import {
+  __async
+} from "./chunk-E7XGHGC7.mjs";
+
+// src/bundlers/vite/index.ts
+var debug = createDebug();
+function UnifiedViteWeappTailwindcssPlugin(options = {}) {
+  const opts = getOptions(options);
+  const {
+    disabled,
+    onEnd,
+    onLoad,
+    onStart,
+    onUpdate,
+    templateHandler,
+    styleHandler,
+    patch,
+    jsHandler,
+    mainCssChunkMatcher,
+    appType,
+    setMangleRuntimeSet,
+    cache,
+    twPatcher
+  } = opts;
+  if (disabled) {
+    return;
+  }
+  patch == null ? void 0 : patch();
+  onLoad();
+  return {
+    name: vitePluginName,
+    enforce: "post",
+    generateBundle(opt, bundle) {
+      return __async(this, null, function* () {
+        debug("start");
+        onStart();
+        const entries = Object.entries(bundle);
+        const groupedEntries = getGroupedEntries(entries, opts);
+        const runtimeSet = twPatcher.getClassSet();
+        setMangleRuntimeSet(runtimeSet);
+        debug("get runtimeSet, class count: %d", runtimeSet.size);
+        if (Array.isArray(groupedEntries.html)) {
+          let noCachedCount = 0;
+          for (let i = 0; i < groupedEntries.html.length; i++) {
+            const [file, originalSource] = groupedEntries.html[i];
+            const oldVal = originalSource.source.toString();
+            const hash = cache.computeHash(oldVal);
+            cache.calcHashValueChanged(file, hash);
+            yield cache.process(
+              file,
+              () => {
+                const source = cache.get(file);
+                if (source) {
+                  originalSource.source = source;
+                  debug("html cache hit: %s", file);
+                } else {
+                  return false;
+                }
+              },
+              () => __async(this, null, function* () {
+                originalSource.source = yield templateHandler(oldVal, {
+                  runtimeSet
+                });
+                onUpdate(file, oldVal, originalSource.source);
+                debug("html handle: %s", file);
+                noCachedCount++;
+                return {
+                  key: file,
+                  source: originalSource.source
+                };
+              })
+            );
+          }
+          debug("html handle finish, total: %d, no-cached: %d", groupedEntries.html.length, noCachedCount);
+        }
+        if (Array.isArray(groupedEntries.js)) {
+          let noCachedCount = 0;
+          for (let i = 0; i < groupedEntries.js.length; i++) {
+            const [file, originalSource] = groupedEntries.js[i];
+            const rawSource = originalSource.code;
+            const hash = cache.computeHash(rawSource);
+            cache.calcHashValueChanged(file, hash);
+            yield cache.process(
+              file,
+              () => {
+                const source = cache.get(file);
+                if (source) {
+                  originalSource.code = source;
+                  debug("js cache hit: %s", file);
+                } else {
+                  return false;
+                }
+              },
+              () => __async(this, null, function* () {
+                const mapFilename = `${file}.map`;
+                const hasMap = Boolean(bundle[mapFilename]);
+                const { code, map } = yield jsHandler(rawSource, runtimeSet, {
+                  generateMap: hasMap
+                });
+                originalSource.code = code;
+                onUpdate(file, rawSource, code);
+                debug("js handle: %s", file);
+                noCachedCount++;
+                if (hasMap && map) {
+                  ;
+                  bundle[mapFilename].source = map.toString();
+                }
+                return {
+                  key: file,
+                  source: code
+                };
+              })
+            );
+          }
+          debug("js handle finish, total: %d, no-cached: %d", groupedEntries.js.length, noCachedCount);
+        }
+        if (Array.isArray(groupedEntries.css)) {
+          let noCachedCount = 0;
+          for (let i = 0; i < groupedEntries.css.length; i++) {
+            const [file, originalSource] = groupedEntries.css[i];
+            const rawSource = originalSource.source.toString();
+            const hash = cache.computeHash(rawSource);
+            cache.calcHashValueChanged(file, hash);
+            yield cache.process(
+              file,
+              () => {
+                const source = cache.get(file);
+                if (source) {
+                  originalSource.source = source;
+                  debug("css cache hit: %s", file);
+                } else {
+                  return false;
+                }
+              },
+              () => __async(this, null, function* () {
+                const css = yield styleHandler(rawSource, {
+                  isMainChunk: mainCssChunkMatcher(originalSource.fileName, appType)
+                });
+                originalSource.source = css;
+                onUpdate(file, rawSource, css);
+                debug("css handle: %s", file);
+                noCachedCount++;
+                return {
+                  key: file,
+                  source: css
+                };
+              })
+            );
+          }
+          debug("css handle finish, total: %d, no-cached: %d", groupedEntries.css.length, noCachedCount);
+        }
+        onEnd();
+        debug("end");
+      });
+    }
+  };
+}
+
+export {
+  UnifiedViteWeappTailwindcssPlugin
+};

package/dist/chunk-75EWCRQW.mjs

@@ -0,0 +1,13 @@
+// src/debug/index.ts
+import _createDebug from "debug";
+var _debug = _createDebug("weapp-tw");
+function createDebug(prefix) {
+  function debug(formatter, ...args) {
+    return _debug((prefix != null ? prefix : "") + formatter, ...args);
+  }
+  return debug;
+}
+
+export {
+  createDebug
+};

package/dist/chunk-AB467PG7.mjs

@@ -0,0 +1,43 @@
+// src/css-macro/constants.ts
+var queryKey = "weapp-tw-platform";
+function createMediaQuery(value) {
+  return `@media (${queryKey}:"${value}"){&}`;
+}
+function createNegativeMediaQuery(value) {
+  return `@media not screen and (${queryKey}:"${value}"){&}`;
+}
+function normalComment(text) {
+  if (typeof text === "string") {
+    return text.replaceAll(new RegExp("(?<!\\\\)_", "g"), " ");
+  }
+  return text;
+}
+function ifdef(text) {
+  return {
+    start: `#ifdef ${normalComment(text)}`,
+    end: `#endif`
+  };
+}
+function ifndef(text) {
+  return {
+    start: `#ifndef ${normalComment(text)}`,
+    end: `#endif`
+  };
+}
+function matchCustomPropertyFromValue(str, cb) {
+  let arr;
+  let index = 0;
+  const regex = new RegExp(`\\(\\s*${queryKey}\\s*:\\s*"([^)]*)"\\)`, "g");
+  while ((arr = regex.exec(str)) !== null) {
+    cb(arr, index);
+    index++;
+  }
+}
+
+export {
+  createMediaQuery,
+  createNegativeMediaQuery,
+  ifdef,
+  ifndef,
+  matchCustomPropertyFromValue
+};

package/dist/chunk-E7XGHGC7.mjs

@@ -0,0 +1,62 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __export,
+  __reExport,
+  __async
+};

package/dist/chunk-GUE4UCRJ.mjs

@@ -0,0 +1,126 @@
+// ../../node_modules/.pnpm/defu@6.1.4/node_modules/defu/dist/defu.mjs
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject(value) && isPlainObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+var defu = createDefu();
+var defuFn = createDefu((object, key, currentValue) => {
+  if (object[key] !== void 0 && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+var defuArrayFn = createDefu((object, key, currentValue) => {
+  if (Array.isArray(object[key]) && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+
+// src/utils.ts
+function isMap(value) {
+  return Object.prototype.toString.call(value) === "[object Map]";
+}
+function noop() {
+}
+function groupBy(arr, cb) {
+  if (!Array.isArray(arr)) {
+    throw new TypeError("expected an array for first argument");
+  }
+  if (typeof cb !== "function") {
+    throw new TypeError("expected a function for second argument");
+  }
+  const result = {};
+  for (const item of arr) {
+    const bucketCategory = cb(item);
+    const bucket = result[bucketCategory];
+    if (Array.isArray(bucket)) {
+      result[bucketCategory].push(item);
+    } else {
+      result[bucketCategory] = [item];
+    }
+  }
+  return result;
+}
+function getGroupedEntries(entries, options) {
+  const { cssMatcher, htmlMatcher, jsMatcher, wxsMatcher } = options;
+  const groupedEntries = groupBy(entries, ([file]) => {
+    if (cssMatcher(file)) {
+      return "css";
+    } else if (htmlMatcher(file)) {
+      return "html";
+    } else if (jsMatcher(file) || wxsMatcher(file)) {
+      return "js";
+    } else {
+      return "other";
+    }
+  });
+  return groupedEntries;
+}
+function removeExt(file) {
+  return file.replace(/\.[^./]+$/, "");
+}
+var defuOverrideArray = createDefu((obj, key, value) => {
+  if (Array.isArray(obj[key]) && Array.isArray(value)) {
+    obj[key] = value;
+    return true;
+  }
+});
+
+export {
+  defu,
+  isMap,
+  noop,
+  getGroupedEntries,
+  removeExt,
+  defuOverrideArray
+};