weapp-tailwindcss 2.4.1 → 2.4.3

package/dist/{options-b3e419f1.js → options-2e71e6b3.js}

@@ -6,14 +6,15 @@ var generate = require('@babel/generator');
 var parser = require('@babel/parser');
 var traverse = require('@babel/traverse');
 var replace = require('./replace.js');
-var shared = require('./shared-823d1fc1.js');
+var shared = require('./shared-cdb5ee55.js');
 var postcss = require('postcss');
-var postcss$1 = require('./postcss-06f57f3f.js');
+var postcss$1 = require('./postcss-b8952a11.js');
 var postcssIsPseudoClass = require('@csstools/postcss-is-pseudo-class');
 var path = require('node:path');
 var fs = require('node:fs');
 var semver = require('semver');
 var tailwindcssPatch = require('tailwindcss-patch');
+var tailwindcssMangleShared = require('tailwindcss-mangle-shared');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -85,12 +86,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 = shared.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)) {
@@ -99,9 +240,10 @@ function handleValue(str, node, options) {
                 ignoreFlag = node.leadingComments.findIndex((x) => x.value.includes('weapp-tw') && x.value.includes('ignore')) > -1;
             }
             if (!ignoreFlag) {
-                const { jsHandler } = shared.useStore();
-                rawStr = jsHandler(rawStr);
-                rawStr = rawStr.replaceAll(new RegExp(shared.escapeStringRegexp(v), 'g'), replace.replaceJs(v, {
+                if (ctx) {
+                    rawStr = ctx.jsHandler(rawStr);
+                }
+                rawStr = rawStr.replaceAll(new RegExp(escapeStringRegexp(v), 'g'), replace.replaceJs(v, {
                     escapeMap
                 }));
             }
@@ -146,11 +288,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
         });
     };
 }
@@ -204,11 +349,11 @@ const defaultOptions = {
     cssPreflightRange: 'view',
     replaceUniversalSelectorWith: 'view',
     disabled: false,
-    customRuleCallback: shared.noop,
-    onLoad: shared.noop,
-    onStart: shared.noop,
-    onEnd: shared.noop,
-    onUpdate: shared.noop,
+    customRuleCallback: noop,
+    onLoad: noop,
+    onStart: noop,
+    onEnd: noop,
+    onUpdate: noop,
     customAttributes: {},
     customReplaceDictionary: shared.SimpleMappingChars2String,
     supportCustomLengthUnitsPatch: {
@@ -221,7 +366,10 @@ const defaultOptions = {
             overwrite: true
         }
     },
-    appType: undefined
+    appType: undefined,
+    arbitraryValues: {
+        allowDoubleQuotes: false
+    }
 };
 
 function generateCode(match, options = {}) {
@@ -250,11 +398,11 @@ function generateCode(match, options = {}) {
     return code;
 }
 function extractSource(original) {
-    let match = shared.variableMatch(original);
+    let match = variableMatch(original);
     const sources = [];
     while (match !== null) {
         const start = match.index;
-        const end = shared.variableRegExp.lastIndex;
+        const end = variableRegExp.lastIndex;
         sources.push({
             start,
             end,
@@ -262,7 +410,7 @@ function extractSource(original) {
             prevConcatenated: !/\s/.test(original[start - 1]),
             nextConcatenated: !/\s/.test(original[end])
         });
-        match = shared.variableMatch(original);
+        match = variableMatch(original);
     }
     return sources;
 }
@@ -276,7 +424,8 @@ function templeteReplacer(original, options = {}) {
             const before = original.slice(p, m.start);
             resultArray.push(replace.replaceJs(before, {
                 keepEOL: true,
-                escapeMap: options.escapeMap
+                escapeMap: options.escapeMap,
+                mangleContext: options.mangleContext
             }));
             p = m.start;
             if (m.raw.trim().length > 0) {
@@ -293,32 +442,31 @@ function templeteReplacer(original, options = {}) {
                 const after = original.slice(m.end);
                 resultArray.push(replace.replaceJs(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 replace.replaceJs(original, {
             keepEOL: false,
-            escapeMap: options.escapeMap
+            escapeMap: options.escapeMap,
+            mangleContext: options.mangleContext
         });
     }
 }
 function templeteHandler(rawSource, options = {}) {
-    return rawSource.replace(shared.tagWithEitherClassAndHoverClassRegexp, (m0) => {
-        return m0.replace(shared.templateClassExactRegexp, (m1, className) => {
+    return rawSource.replace(tagWithEitherClassAndHoverClassRegexp, (m0) => {
+        return m0.replace(templateClassExactRegexp, (m1, className) => {
             return m1.replace(className, templeteReplacer(className, options));
         });
     });
 }
 function customTempleteHandler(rawSource, options = {}) {
     let source = templeteHandler(rawSource, options);
-    const regexps = shared.makeCustomAttributes(options.customAttributesEntities);
+    const regexps = makeCustomAttributes(options.customAttributesEntities);
     if (regexps) {
         if (Array.isArray(regexps)) {
             for (const regexp of regexps) {
@@ -423,7 +571,7 @@ function getInstalledPkgJsonPath(options) {
 }
 function createPatch(options) {
     if (options === false) {
-        return shared.noop;
+        return noop;
     }
     return () => {
         try {
@@ -483,6 +631,72 @@ function createTailwindcssPatcher() {
     });
 }
 
+function getSelf(x) {
+    return x;
+}
+const defaultMangleContext = {
+    rawOptions: false,
+    runtimeSet: new Set(),
+    classGenerator: new tailwindcssMangleShared.ClassGenerator(),
+    filter: tailwindcssMangleShared.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: tailwindcssMangleShared.defaultMangleClassFilter
+                };
+            }
+            ctx.classGenerator = new tailwindcssMangleShared.ClassGenerator(options.classGenerator);
+            ctx.filter = (_a = options.mangleClassFilter) !== null && _a !== void 0 ? _a : tailwindcssMangleShared.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 micromatch.isMatch(file, pattern);
@@ -493,18 +707,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;
     }
@@ -521,38 +724,40 @@ 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 = shared.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;
 }
 
 exports.createPatch = createPatch;
 exports.createTailwindcssPatcher = createTailwindcssPatcher;
+exports.getGroupedEntries = getGroupedEntries;
 exports.getOptions = getOptions;