weapp-tailwindcss 2.4.1 → 2.4.3

package/dist/{options-3578215d.mjs → options-a2ba3653.mjs}

@@ -4,14 +4,15 @@ import generate from '@babel/generator';
 import { parse, parseExpression } from '@babel/parser';
 import traverse from '@babel/traverse';
 import { replaceJs as replaceWxml } from './replace.mjs';
-import { s as splitCode, e as escapeStringRegexp, u as useStore, n as noop, S as SimpleMappingChars2String, m as makeCustomAttributes, t as tagWithEitherClassAndHoverClassRegexp, a as templateClassExactRegexp, v as variableMatch, b as variableRegExp, M as MappingChars2String, i as isMap } from './shared-497eda3c.mjs';
+import { S as SimpleMappingChars2String, M as MappingChars2String } from './shared-fc50603a.mjs';
 import postcss from 'postcss';
-import { p as postcssWeappTailwindcss } from './postcss-564aef44.mjs';
+import { p as postcssWeappTailwindcss } from './postcss-15e2ef2d.mjs';
 import postcssIsPseudoClass from '@csstools/postcss-is-pseudo-class';
 import path from 'node:path';
 import fs from 'node:fs';
 import { gte } from 'semver';
 import { monkeyPatchForExposingContext, requireResolve, TailwindcssPatcher } from 'tailwindcss-patch';
+import { ClassGenerator, defaultMangleClassFilter } from 'tailwindcss-mangle-shared';
 
 function isObject(value) {
   return value !== null && typeof value === "object";
@@ -55,12 +56,152 @@ function createDefu(merger) {
 }
 const defu = createDefu();
 
+function isRegexp(value) {
+    return Object.prototype.toString.call(value) === '[object RegExp]';
+}
+function isMap(value) {
+    return Object.prototype.toString.call(value) === '[object Map]';
+}
+const 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 } = options;
+    const groupedEntries = groupBy(entries, ([file]) => {
+        if (cssMatcher(file)) {
+            return 'css';
+        }
+        else if (htmlMatcher(file)) {
+            return 'html';
+        }
+        else if (jsMatcher(file)) {
+            return 'js';
+        }
+        else {
+            return 'other';
+        }
+    });
+    return groupedEntries;
+}
+
+function escapeStringRegexp(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Expected a string');
+    }
+    return str.replaceAll(/[$()*+.?[\\\]^{|}]/g, '\\$&').replaceAll('-', '\\x2d');
+}
+const templateClassExactRegexp = /(?<=^|\s)(?:hover-)?class=(?:["']\W+\s*\w+\()?["']([^"]+)["']/gs;
+const tagWithEitherClassAndHoverClassRegexp = /<[a-z][a-z-]*[a-z]*\s+[^>]*?(?:hover-)?clas{2}="[^"]*"[^>]*?\/?>/g;
+function handleRegexp(reg) {
+    return `(?:${reg.source})`;
+}
+function getSourceString(input) {
+    let result;
+    if (typeof input === 'string') {
+        result = input;
+    }
+    else if (isRegexp(input)) {
+        result = input.source;
+    }
+    else {
+        result = input.toString();
+    }
+    return result;
+}
+function makePattern(arr) {
+    let pattern = '';
+    if (Array.isArray(arr)) {
+        pattern = arr
+            .reduce((acc, cur) => {
+            if (typeof cur === 'string') {
+                acc.push(cur);
+            }
+            else if (isRegexp(cur)) {
+                acc.push(handleRegexp(cur));
+            }
+            return acc;
+        }, [])
+            .join('|');
+    }
+    else if (typeof arr === 'string') {
+        pattern = arr;
+    }
+    else if (isRegexp(arr)) {
+        pattern = handleRegexp(arr);
+    }
+    return pattern;
+}
+function createTempleteHandlerMatchRegexp(tag, attrs, options = {}) {
+    const { exact = true } = options;
+    const prefix = exact ? '(?<=^|\\s)' : '';
+    const pattern = makePattern(attrs);
+    let tagPattern = getSourceString(tag);
+    if (tagPattern === '*') {
+        tagPattern = '[a-z][-a-z]*[a-z]*';
+    }
+    const source = `<(${tagPattern})\\s+[^>]*?(?:${prefix}(${pattern})="(?:[^"]*)")[^>]*?\\/?>`;
+    return new RegExp(source, 'g');
+}
+function createTemplateClassRegexp(attrs, options = {}) {
+    const { exact = true } = options;
+    const prefix = exact ? '(?<=^|\\s)' : '';
+    const pattern = makePattern(attrs);
+    const source = `(?:${prefix}${pattern})=(?:["']\\W+\\s*(?:\\w+)\\()?["']([^"]+)['"]`;
+    return new RegExp(source, 'gs');
+}
+function makeCustomAttributes(entries) {
+    if (Array.isArray(entries)) {
+        return entries.map(([k, v]) => {
+            return {
+                tagRegexp: createTempleteHandlerMatchRegexp(k, v),
+                attrRegexp: createTemplateClassRegexp(v),
+                tag: getSourceString(k),
+                attrs: v
+            };
+        });
+    }
+}
+const variableRegExp = /{{(.*?)}}/gs;
+function variableMatch(original) {
+    return variableRegExp.exec(original);
+}
+
+const validateFilterRE = /[\w%-?\u00A0-\uFFFF-]/;
+function isValidSelector(selector = '') {
+    return validateFilterRE.test(selector);
+}
+const splitCode = (code, allowDoubleQuotes = false) => {
+    const splitter = allowDoubleQuotes ? /\s+/ : /\s+|"/;
+    return code.split(splitter).filter((element) => isValidSelector(element));
+};
+
 const isProd = () => process.env.NODE_ENV === 'production';
 
 function handleValue(str, node, options) {
+    var _a;
     const set = options.classNameSet;
     const escapeMap = options.escapeMap;
-    const arr = splitCode(str);
+    const allowDoubleQuotes = (_a = options.arbitraryValues) === null || _a === void 0 ? void 0 : _a.allowDoubleQuotes;
+    const ctx = options.mangleContext;
+    const arr = splitCode(str, allowDoubleQuotes);
     let rawStr = str;
     for (const v of arr) {
         if (set.has(v)) {
@@ -69,8 +210,9 @@ function handleValue(str, node, options) {
                 ignoreFlag = node.leadingComments.findIndex((x) => x.value.includes('weapp-tw') && x.value.includes('ignore')) > -1;
             }
             if (!ignoreFlag) {
-                const { jsHandler } = useStore();
-                rawStr = jsHandler(rawStr);
+                if (ctx) {
+                    rawStr = ctx.jsHandler(rawStr);
+                }
                 rawStr = rawStr.replaceAll(new RegExp(escapeStringRegexp(v), 'g'), replaceWxml(v, {
                     escapeMap
                 }));
@@ -116,11 +258,14 @@ function jsHandler(rawSource, options) {
     });
 }
 function createjsHandler(options) {
+    const { mangleContext, arbitraryValues, minifiedJs, escapeMap } = options;
     return (rawSource, set) => {
         return jsHandler(rawSource, {
             classNameSet: set,
-            minifiedJs: options.minifiedJs,
-            escapeMap: options.escapeMap
+            minifiedJs,
+            escapeMap,
+            arbitraryValues,
+            mangleContext
         });
     };
 }
@@ -191,7 +336,10 @@ const defaultOptions = {
             overwrite: true
         }
     },
-    appType: undefined
+    appType: undefined,
+    arbitraryValues: {
+        allowDoubleQuotes: false
+    }
 };
 
 function generateCode(match, options = {}) {
@@ -246,7 +394,8 @@ function templeteReplacer(original, options = {}) {
             const before = original.slice(p, m.start);
             resultArray.push(replaceWxml(before, {
                 keepEOL: true,
-                escapeMap: options.escapeMap
+                escapeMap: options.escapeMap,
+                mangleContext: options.mangleContext
             }));
             p = m.start;
             if (m.raw.trim().length > 0) {
@@ -263,19 +412,18 @@ function templeteReplacer(original, options = {}) {
                 const after = original.slice(m.end);
                 resultArray.push(replaceWxml(after, {
                     keepEOL: true,
-                    escapeMap: options.escapeMap
+                    escapeMap: options.escapeMap,
+                    mangleContext: options.mangleContext
                 }));
             }
         }
-        return resultArray
-            .filter(Boolean)
-            .join('')
-            .trim();
+        return resultArray.filter(Boolean).join('').trim();
     }
     else {
         return replaceWxml(original, {
             keepEOL: false,
-            escapeMap: options.escapeMap
+            escapeMap: options.escapeMap,
+            mangleContext: options.mangleContext
         });
     }
 }
@@ -453,6 +601,72 @@ function createTailwindcssPatcher() {
     });
 }
 
+function getSelf(x) {
+    return x;
+}
+const defaultMangleContext = {
+    rawOptions: false,
+    runtimeSet: new Set(),
+    classGenerator: new ClassGenerator(),
+    filter: defaultMangleClassFilter,
+    cssHandler: getSelf,
+    jsHandler: getSelf,
+    wxmlHandler: getSelf
+};
+function useMangleStore() {
+    const ctx = Object.assign({}, defaultMangleContext);
+    function resetMangle() {
+        return Object.assign(ctx, defaultMangleContext);
+    }
+    function handleValue(rawSource) {
+        const arr = splitCode(rawSource);
+        for (const x of arr) {
+            if (ctx.runtimeSet.has(x)) {
+                rawSource = rawSource.replaceAll(new RegExp(escapeStringRegexp(x), 'g'), ctx.classGenerator.generateClassName(x).name);
+            }
+        }
+        return rawSource;
+    }
+    function initMangle(options) {
+        var _a;
+        ctx.rawOptions = options;
+        if (options) {
+            if (options === true) {
+                options = {
+                    classGenerator: {},
+                    mangleClassFilter: defaultMangleClassFilter
+                };
+            }
+            ctx.classGenerator = new ClassGenerator(options.classGenerator);
+            ctx.filter = (_a = options.mangleClassFilter) !== null && _a !== void 0 ? _a : defaultMangleClassFilter;
+            ctx.jsHandler = (rawSource) => {
+                return handleValue(rawSource);
+            };
+            ctx.cssHandler = (rawSource) => {
+                return handleValue(rawSource);
+            };
+            ctx.wxmlHandler = (rawSource) => {
+                return handleValue(rawSource);
+            };
+        }
+    }
+    function setMangleRuntimeSet(runtimeSet) {
+        const newSet = new Set();
+        for (const c of runtimeSet) {
+            if (ctx.filter(c)) {
+                newSet.add(c);
+            }
+        }
+        ctx.runtimeSet = newSet;
+    }
+    return {
+        mangleContext: ctx,
+        resetMangle,
+        initMangle,
+        setMangleRuntimeSet
+    };
+}
+
 function createGlobMatcher(pattern) {
     return function (file) {
         return isMatch(file, pattern);
@@ -463,18 +677,7 @@ function normalizeMatcher(options, key) {
         options[key] = createGlobMatcher(options[key]);
     }
 }
-function getOptions(options = {}, modules = ['style', 'templete', 'patch', 'js']) {
-    const registerModules = modules.reduce((acc, cur) => {
-        if (acc[cur] !== undefined) {
-            acc[cur] = true;
-        }
-        return acc;
-    }, {
-        templete: false,
-        style: false,
-        patch: false,
-        js: false
-    });
+function getOptions(options = {}) {
     if (options.supportCustomLengthUnitsPatch === true) {
         options.supportCustomLengthUnitsPatch = undefined;
     }
@@ -491,36 +694,37 @@ function getOptions(options = {}, modules = ['style', 'templete', 'patch', 'js']
     const result = defu(options, defaultOptions, {
         minifiedJs: isProd()
     });
-    const { cssPreflight, customRuleCallback, cssPreflightRange, replaceUniversalSelectorWith, customAttributes, customReplaceDictionary, supportCustomLengthUnitsPatch } = result;
+    const { cssPreflight, customRuleCallback, cssPreflightRange, replaceUniversalSelectorWith, customAttributes, customReplaceDictionary, supportCustomLengthUnitsPatch, arbitraryValues } = result;
     result.escapeMap = customReplaceDictionary;
     const cssInjectPreflight = createInjectPreflight(cssPreflight);
-    const customAttributesEntities = isMap(options.customAttributes) ? [...options.customAttributes.entries()] : Object.entries(customAttributes);
+    const customAttributesEntities = isMap(options.customAttributes)
+        ? [...options.customAttributes.entries()]
+        : Object.entries(customAttributes);
     const { escapeMap, minifiedJs } = result;
-    if (registerModules.templete) {
-        result.templeteHandler = createTempleteHandler({
-            customAttributesEntities,
-            escapeMap
-        });
-    }
-    if (registerModules.style) {
-        result.styleHandler = createStyleHandler({
-            cssInjectPreflight,
-            customRuleCallback,
-            cssPreflightRange,
-            replaceUniversalSelectorWith,
-            escapeMap
-        });
-    }
-    if (registerModules.js) {
-        result.jsHandler = createjsHandler({
-            minifiedJs,
-            escapeMap
-        });
-    }
-    if (registerModules.patch) {
-        result.patch = createPatch(supportCustomLengthUnitsPatch);
-    }
+    const { initMangle, mangleContext, setMangleRuntimeSet } = useMangleStore();
+    initMangle(options.mangle);
+    result.templeteHandler = createTempleteHandler({
+        customAttributesEntities,
+        escapeMap,
+        mangleContext
+    });
+    result.styleHandler = createStyleHandler({
+        cssInjectPreflight,
+        customRuleCallback,
+        cssPreflightRange,
+        replaceUniversalSelectorWith,
+        escapeMap,
+        mangleContext
+    });
+    result.jsHandler = createjsHandler({
+        minifiedJs,
+        escapeMap,
+        mangleContext,
+        arbitraryValues
+    });
+    result.patch = createPatch(supportCustomLengthUnitsPatch);
+    result.setMangleRuntimeSet = setMangleRuntimeSet;
     return result;
 }
 
-export { createTailwindcssPatcher as a, createPatch as c, getOptions as g };
+export { createTailwindcssPatcher as a, getGroupedEntries as b, createPatch as c, getOptions as g };

package/dist/options.d.ts

@@ -1,4 +1,2 @@
 import type { InternalUserDefinedOptions, UserDefinedOptions } from './types';
-type IModules = readonly ('js' | 'style' | 'templete' | 'patch')[];
-export declare function getOptions(options?: UserDefinedOptions, modules?: IModules): InternalUserDefinedOptions;
-export {};
+export declare function getOptions(options?: UserDefinedOptions): InternalUserDefinedOptions;

package/dist/postcss/index.d.ts

@@ -1,3 +1,3 @@
 import type { IStyleHandlerOptions } from "../types";
 export declare function styleHandler(rawSource: string, options: IStyleHandlerOptions): string;
-export declare function createStyleHandler(options: Partial<IStyleHandlerOptions>): (rawSource: string, opt: IStyleHandlerOptions) => string;
+export declare function createStyleHandler(options: Partial<IStyleHandlerOptions>): (rawSource: string, opt?: Partial<IStyleHandlerOptions>) => string;

package/dist/postcss/shared.d.ts

@@ -1 +1,3 @@
-export declare function internalCssSelectorReplacer(selectors: string, map?: Record<string, string>): string;
+import { InternalCssSelectorReplacerOptions } from "../types";
+export declare function internalCssSelectorReplacer(selectors: string, options?: InternalCssSelectorReplacerOptions): string;
+export declare function cssUnescape(value: string): string;

package/dist/{postcss-564aef44.mjs → postcss-15e2ef2d.mjs}

@@ -1,21 +1,25 @@
 import selectorParser from 'postcss-selector-parser';
-import { f as internalCssSelectorReplacer } from './shared-497eda3c.mjs';
+import { i as internalCssSelectorReplacer } from './shared-fc50603a.mjs';
 import { Rule, Declaration } from 'postcss';
 import '@csstools/postcss-is-pseudo-class';
 
 const createTransform = (rule, options) => {
-    const replaceFlag = options.replaceUniversalSelectorWith !== false;
+    const { replaceUniversalSelectorWith, escapeMap, mangleContext } = options;
+    const replaceFlag = replaceUniversalSelectorWith !== false;
     const transform = (selectors) => {
         selectors.walk((selector) => {
             if (selector.type === 'universal' && replaceFlag) {
-                selector.value = options.replaceUniversalSelectorWith;
+                selector.value = replaceUniversalSelectorWith;
             }
             if (selector.type === 'selector') {
                 const node = selector.nodes.find((x) => x.type === 'pseudo' && x.value === ':hover');
                 node && selector.remove();
             }
             if (selector.type === 'class') {
-                selector.value = internalCssSelectorReplacer(selector.value, options.escapeMap);
+                selector.value = internalCssSelectorReplacer(selector.value, {
+                    escapeMap,
+                    mangleContext
+                });
             }
         });
         if (selectors.length === 0) {

package/dist/{postcss-06f57f3f.js → postcss-b8952a11.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 var selectorParser = require('postcss-selector-parser');
-var shared = require('./shared-823d1fc1.js');
+var shared = require('./shared-cdb5ee55.js');
 var postcss = require('postcss');
 require('@csstools/postcss-is-pseudo-class');
 
@@ -10,18 +10,22 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 var selectorParser__default = /*#__PURE__*/_interopDefaultCompat(selectorParser);
 
 const createTransform = (rule, options) => {
-    const replaceFlag = options.replaceUniversalSelectorWith !== false;
+    const { replaceUniversalSelectorWith, escapeMap, mangleContext } = options;
+    const replaceFlag = replaceUniversalSelectorWith !== false;
     const transform = (selectors) => {
         selectors.walk((selector) => {
             if (selector.type === 'universal' && replaceFlag) {
-                selector.value = options.replaceUniversalSelectorWith;
+                selector.value = replaceUniversalSelectorWith;
             }
             if (selector.type === 'selector') {
                 const node = selector.nodes.find((x) => x.type === 'pseudo' && x.value === ':hover');
                 node && selector.remove();
             }
             if (selector.type === 'class') {
-                selector.value = shared.internalCssSelectorReplacer(selector.value, options.escapeMap);
+                selector.value = shared.internalCssSelectorReplacer(selector.value, {
+                    escapeMap,
+                    mangleContext
+                });
             }
         });
         if (selectors.length === 0) {

package/dist/postcss.js

@@ -2,11 +2,10 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var postcss = require('./postcss-06f57f3f.js');
+var postcss = require('./postcss-b8952a11.js');
 var postcssIsPseudoClass = require('@csstools/postcss-is-pseudo-class');
 require('postcss-selector-parser');
-require('./shared-823d1fc1.js');
-require('tailwindcss-mangle-shared');
+require('./shared-cdb5ee55.js');
 require('postcss');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

package/dist/postcss.mjs

@@ -1,6 +1,5 @@
-export { p as postcssWeappTailwindcss } from './postcss-564aef44.mjs';
+export { p as postcssWeappTailwindcss } from './postcss-15e2ef2d.mjs';
 export { default as postcssIsPseudoClass } from '@csstools/postcss-is-pseudo-class';
 import 'postcss-selector-parser';
-import './shared-497eda3c.mjs';
-import 'tailwindcss-mangle-shared';
+import './shared-fc50603a.mjs';
 import 'postcss';

package/dist/replace.js

@@ -2,27 +2,23 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var shared = require('./shared-823d1fc1.js');
-require('tailwindcss-mangle-shared');
+var shared = require('./shared-cdb5ee55.js');
 
 function replaceWxml(original, options = {
     keepEOL: false,
     escapeMap: shared.SimpleMappingChars2String
 }) {
-    if (typeof options === 'boolean') {
-        options = {
-            keepEOL: options
-        };
-    }
+    const { keepEOL, escapeMap, mangleContext } = options;
     let res = original;
-    if (!options.keepEOL) {
+    if (!keepEOL) {
         res = res
             .replaceAll(/[\n\r]+/g, '');
     }
-    const { wxmlHandler } = shared.useStore();
-    res = wxmlHandler(res);
+    if (mangleContext) {
+        res = mangleContext.wxmlHandler(res);
+    }
     res = shared.escape(res, {
-        map: options.escapeMap
+        map: escapeMap
     });
     return res;
 }

package/dist/replace.mjs

@@ -1,25 +1,21 @@
-import { h as escape, S as SimpleMappingChars2String, u as useStore } from './shared-497eda3c.mjs';
-export { M as MappingChars2String, k as MappingChars2StringEntries, j as SYMBOL_TABLE, l as SimpleMappingChars2StringEntries, f as replaceCss } from './shared-497eda3c.mjs';
-import 'tailwindcss-mangle-shared';
+import { e as escape, S as SimpleMappingChars2String } from './shared-fc50603a.mjs';
+export { M as MappingChars2String, b as MappingChars2StringEntries, a as SYMBOL_TABLE, c as SimpleMappingChars2StringEntries, i as replaceCss } from './shared-fc50603a.mjs';
 
 function replaceWxml(original, options = {
     keepEOL: false,
     escapeMap: SimpleMappingChars2String
 }) {
-    if (typeof options === 'boolean') {
-        options = {
-            keepEOL: options
-        };
-    }
+    const { keepEOL, escapeMap, mangleContext } = options;
     let res = original;
-    if (!options.keepEOL) {
+    if (!keepEOL) {
         res = res
             .replaceAll(/[\n\r]+/g, '');
     }
-    const { wxmlHandler } = useStore();
-    res = wxmlHandler(res);
+    if (mangleContext) {
+        res = mangleContext.wxmlHandler(res);
+    }
     res = escape(res, {
-        map: options.escapeMap
+        map: escapeMap
     });
     return res;
 }