weapp-tailwindcss 3.3.7 → 3.4.0-alpha.0

package/dist/core.mjs

@@ -1,65 +1,49 @@
-import { g as getOptions, _ as __awaiter } from './options-BHJnjA_a.mjs';
-import 'magic-string';
-import './replace.mjs';
-import '@weapp-core/escape';
-import '@ast-core/escape';
-import './shared-DbJl6i6a.mjs';
-import '@weapp-core/regex';
-import '@babel/generator';
-import '@babel/traverse';
-import '@babel/parser';
-import './defaults-DUZZvtdg.mjs';
-import './defu-n46TJT6t.mjs';
-import '@babel/types';
-import 'htmlparser2';
-import 'postcss';
-import './index-BPzIdybK.mjs';
-import '@csstools/postcss-is-pseudo-class';
-import 'postcss-rem-to-responsive-pixel';
-import 'postcss-selector-parser';
-import 'node:path';
-import 'node:fs';
-import 'node:process';
-import 'semver';
-import 'tailwindcss-patch';
-import '@tailwindcss-mangle/shared';
-import 'lru-cache';
-import 'md5';
+import {
+  getOptions
+} from "./chunk-PC4B5JJB.mjs";
+import "./chunk-SRLZU2YE.mjs";
+import "./chunk-GUE4UCRJ.mjs";
+import "./chunk-IOYI6MSW.mjs";
+import "./chunk-NVFWRLOI.mjs";
+import "./chunk-ORMKM6ZA.mjs";
+import "./chunk-VECXHWWG.mjs";
+import {
+  __async
+} from "./chunk-E7XGHGC7.mjs";
 
+// src/core.ts
 function createContext(options = {}) {
-    const opts = getOptions(options);
-    const { templateHandler, styleHandler, patch, jsHandler, twPatcher } = opts;
-    let runtimeSet = new Set();
-    patch === null || patch === void 0 ? void 0 : patch();
-    function transformWxss(rawCss, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const code = yield styleHandler(rawCss, Object.assign({
-                isMainChunk: true,
-            }, options));
-            return code;
-        });
-    }
-    function transformJs(rawJs_1) {
-        return __awaiter(this, arguments, void 0, function* (rawJs, options = {}) {
-            runtimeSet
-                = options && options.runtimeSet
-                    ? options.runtimeSet
-                    : twPatcher.getClassSet();
-            const { code } = yield jsHandler(rawJs, runtimeSet, options);
-            return code;
-        });
-    }
-    function transformWxml(rawWxml, options) {
-        const code = templateHandler(rawWxml, Object.assign({
-            runtimeSet,
-        }, options));
-        return code;
-    }
-    return {
-        transformWxss,
-        transformWxml,
-        transformJs,
-    };
+  const opts = getOptions(options);
+  const { templateHandler, styleHandler, patch, jsHandler, twPatcher } = opts;
+  let runtimeSet = /* @__PURE__ */ new Set();
+  patch == null ? void 0 : patch();
+  function transformWxss(rawCss, options2) {
+    return __async(this, null, function* () {
+      const code = yield styleHandler(rawCss, Object.assign({
+        isMainChunk: true
+      }, options2));
+      return code;
+    });
+  }
+  function transformJs(_0) {
+    return __async(this, arguments, function* (rawJs, options2 = {}) {
+      runtimeSet = options2 && options2.runtimeSet ? options2.runtimeSet : twPatcher.getClassSet();
+      const { code } = yield jsHandler(rawJs, runtimeSet, options2);
+      return code;
+    });
+  }
+  function transformWxml(rawWxml, options2) {
+    const code = templateHandler(rawWxml, Object.assign({
+      runtimeSet
+    }, options2));
+    return code;
+  }
+  return {
+    transformWxss,
+    transformWxml,
+    transformJs
+  };
 }
-
-export { createContext };
+export {
+  createContext
+};

package/dist/css-macro/index.d.mts

@@ -0,0 +1,18 @@
+import * as tailwindcss_types_config from 'tailwindcss/types/config';
+
+interface Options {
+    variantsMap?: Record<string, string | {
+        value: string;
+        negative?: boolean;
+    }>;
+    dynamic?: boolean;
+}
+declare const _default: {
+    (options: Options): {
+        handler: tailwindcss_types_config.PluginCreator;
+        config?: Partial<tailwindcss_types_config.Config>;
+    };
+    __isOptionsFunction: true;
+};
+
+export { type Options, _default as default };

package/dist/css-macro/index.d.ts

@@ -1,4 +1,6 @@
-export interface Options {
+import * as tailwindcss_types_config from 'tailwindcss/types/config';
+
+interface Options {
     variantsMap?: Record<string, string | {
         value: string;
         negative?: boolean;
@@ -7,9 +9,10 @@ export interface Options {
 }
 declare const _default: {
     (options: Options): {
-        handler: import("tailwindcss/types/config").PluginCreator;
-        config?: Partial<import("tailwindcss/types/config").Config> | undefined;
+        handler: tailwindcss_types_config.PluginCreator;
+        config?: Partial<tailwindcss_types_config.Config>;
     };
     __isOptionsFunction: true;
 };
-export default _default;
+
+export { type Options, _default as default };

package/dist/css-macro/index.js

@@ -1,36 +1,146 @@
-'use strict';
+"use strict";
+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 __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-var plugin = require('tailwindcss/plugin');
-var constants = require('../constants-CFM1J-h1.js');
-var defu = require('../defu-Cdz2PomB.js');
+// src/css-macro/index.ts
+var css_macro_exports = {};
+__export(css_macro_exports, {
+  default: () => css_macro_default
+});
+module.exports = __toCommonJS(css_macro_exports);
+var import_plugin = __toESM(require("tailwindcss/plugin"));
 
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+// 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}"){&}`;
+}
 
-var plugin__default = /*#__PURE__*/_interopDefaultCompat(plugin);
+// ../../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;
+  }
+});
 
-var index = plugin__default["default"].withOptions((options) => {
-    const { dynamic: dynamicMode, variantsMap } = defu.defu(options, {
-        dynamic: true,
-        variantsMap: {},
-    });
-    return ({ matchVariant, addVariant }) => {
-        if (dynamicMode) {
-            matchVariant('ifdef', (value) => {
-                return constants.createMediaQuery(value);
-            });
-            matchVariant('ifndef', (value) => {
-                return constants.createNegativeMediaQuery(value);
-            });
-        }
-        for (const [name, obj] of Object.entries(variantsMap)) {
-            if (typeof obj === 'string') {
-                addVariant(name, constants.createMediaQuery(obj));
-            }
-            else {
-                addVariant(name, obj.negative ? constants.createNegativeMediaQuery(obj.value) : constants.createMediaQuery(obj.value));
-            }
-        }
-    };
+// src/utils.ts
+var defuOverrideArray = createDefu((obj, key, value) => {
+  if (Array.isArray(obj[key]) && Array.isArray(value)) {
+    obj[key] = value;
+    return true;
+  }
 });
 
-module.exports = index;
+// src/css-macro/index.ts
+var css_macro_default = import_plugin.default.withOptions((options) => {
+  const { dynamic: dynamicMode, variantsMap } = defu(options, {
+    dynamic: true,
+    variantsMap: {}
+  });
+  return ({ matchVariant, addVariant }) => {
+    if (dynamicMode) {
+      matchVariant("ifdef", (value) => {
+        return createMediaQuery(value);
+      });
+      matchVariant("ifndef", (value) => {
+        return createNegativeMediaQuery(value);
+      });
+    }
+    for (const [name, obj] of Object.entries(variantsMap)) {
+      if (typeof obj === "string") {
+        addVariant(name, createMediaQuery(obj));
+      } else {
+        addVariant(name, obj.negative ? createNegativeMediaQuery(obj.value) : createMediaQuery(obj.value));
+      }
+    }
+  };
+});

package/dist/css-macro/index.mjs

@@ -1,30 +1,37 @@
-import plugin from 'tailwindcss/plugin';
-import { c as createMediaQuery, a as createNegativeMediaQuery } from '../constants-Dy2Dd3Fz.mjs';
-import { d as defu } from '../defu-n46TJT6t.mjs';
+import {
+  createMediaQuery,
+  createNegativeMediaQuery
+} from "../chunk-AB467PG7.mjs";
+import {
+  defu
+} from "../chunk-GUE4UCRJ.mjs";
+import "../chunk-E7XGHGC7.mjs";
 
-var index = plugin.withOptions((options) => {
-    const { dynamic: dynamicMode, variantsMap } = defu(options, {
-        dynamic: true,
-        variantsMap: {},
-    });
-    return ({ matchVariant, addVariant }) => {
-        if (dynamicMode) {
-            matchVariant('ifdef', (value) => {
-                return createMediaQuery(value);
-            });
-            matchVariant('ifndef', (value) => {
-                return createNegativeMediaQuery(value);
-            });
-        }
-        for (const [name, obj] of Object.entries(variantsMap)) {
-            if (typeof obj === 'string') {
-                addVariant(name, createMediaQuery(obj));
-            }
-            else {
-                addVariant(name, obj.negative ? createNegativeMediaQuery(obj.value) : createMediaQuery(obj.value));
-            }
-        }
-    };
+// src/css-macro/index.ts
+import plugin from "tailwindcss/plugin";
+var css_macro_default = plugin.withOptions((options) => {
+  const { dynamic: dynamicMode, variantsMap } = defu(options, {
+    dynamic: true,
+    variantsMap: {}
+  });
+  return ({ matchVariant, addVariant }) => {
+    if (dynamicMode) {
+      matchVariant("ifdef", (value) => {
+        return createMediaQuery(value);
+      });
+      matchVariant("ifndef", (value) => {
+        return createNegativeMediaQuery(value);
+      });
+    }
+    for (const [name, obj] of Object.entries(variantsMap)) {
+      if (typeof obj === "string") {
+        addVariant(name, createMediaQuery(obj));
+      } else {
+        addVariant(name, obj.negative ? createNegativeMediaQuery(obj.value) : createMediaQuery(obj.value));
+      }
+    }
+  };
 });
-
-export { index as default };
+export {
+  css_macro_default as default
+};

package/dist/css-macro/postcss.d.mts

@@ -0,0 +1,7 @@
+import { PluginCreator } from 'postcss';
+
+interface Options {
+}
+declare const creator: PluginCreator<Options>;
+
+export { type Options, creator as default };

package/dist/css-macro/postcss.d.ts

@@ -1,5 +1,7 @@
-import type { PluginCreator } from 'postcss';
-export interface Options {
+import { PluginCreator } from 'postcss';
+
+interface Options {
 }
 declare const creator: PluginCreator<Options>;
-export default creator;
+
+export { type Options, creator as default };

package/dist/css-macro/postcss.js

@@ -1,51 +1,104 @@
-'use strict';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-var constants = require('../constants-CFM1J-h1.js');
+// src/css-macro/postcss.ts
+var postcss_exports = {};
+__export(postcss_exports, {
+  default: () => postcss_default
+});
+module.exports = __toCommonJS(postcss_exports);
 
-const creator = () => {
-    return {
-        postcssPlugin: 'postcss-weapp-tw-css-macro-plugin',
-        prepare() {
-            return {
-                AtRule(atRule, helper) {
-                    var _a;
-                    if (atRule.name === 'media') {
-                        const values = [];
-                        constants.matchCustomPropertyFromValue(atRule.params, (arr) => {
-                            values.push(arr[1]);
-                        });
-                        if (values.length > 0) {
-                            const isNegative = atRule.params.includes('not');
-                            const text = values.join(' ');
-                            const comment = isNegative ? constants.ifndef(text) : constants.ifdef(text);
-                            atRule.replaceWith([
-                                helper.comment({
-                                    raws: {
-                                        before: '\n',
-                                    },
-                                    text: comment.start,
-                                }),
-                                ...((_a = atRule.nodes) !== null && _a !== void 0 ? _a : []),
-                                helper.comment({
-                                    raws: {
-                                        before: '\n',
-                                    },
-                                    text: comment.end,
-                                }),
-                            ]);
-                        }
-                    }
-                },
-                CommentExit(comment) {
-                    if (/#(?:ifn?def|endif)/.test(comment.text)) {
-                        comment.raws.left = ' ';
-                        comment.raws.right = ' ';
-                    }
-                },
-            };
+// src/css-macro/constants.ts
+var queryKey = "weapp-tw-platform";
+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++;
+  }
+}
+
+// src/css-macro/postcss.ts
+var creator = () => {
+  return {
+    postcssPlugin: "postcss-weapp-tw-css-macro-plugin",
+    prepare() {
+      return {
+        AtRule(atRule, helper) {
+          var _a;
+          if (atRule.name === "media") {
+            const values = [];
+            matchCustomPropertyFromValue(atRule.params, (arr) => {
+              values.push(arr[1]);
+            });
+            if (values.length > 0) {
+              const isNegative = atRule.params.includes("not");
+              const text = values.join(" ");
+              const comment = isNegative ? ifndef(text) : ifdef(text);
+              atRule.replaceWith([
+                helper.comment({
+                  raws: {
+                    before: "\n"
+                  },
+                  text: comment.start
+                }),
+                ...(_a = atRule.nodes) != null ? _a : [],
+                // .map((x) => x.clone()),
+                helper.comment({
+                  raws: {
+                    before: "\n"
+                  },
+                  text: comment.end
+                })
+              ]);
+            }
+          }
         },
-    };
+        CommentExit(comment) {
+          if (/#(?:ifn?def|endif)/.test(comment.text)) {
+            comment.raws.left = " ";
+            comment.raws.right = " ";
+          }
+        }
+      };
+    }
+  };
 };
 creator.postcss = true;
-
-module.exports = creator;
+var postcss_default = creator;