weapp-tailwindcss 2.11.0 → 3.0.1

package/dist/{options-M8pGfjj_.mjs → options-mJwenBmV.mjs}

@@ -1,19 +1,16 @@
-import { isMatch } from 'micromatch';
 import MagicString from 'magic-string';
 import { replaceJs as replaceWxml } from './replace.mjs';
 import { escapeStringRegexp, variableRegExp } from '@weapp-core/regex';
-import { SimpleMappingChars2String, MappingChars2String } from '@weapp-core/escape';
+import { SimpleMappingChars2String } from '@weapp-core/escape';
 import { jsStringEscape } from '@ast-core/escape';
 import generate from '@babel/generator';
 import { parse, parseExpression } from '@babel/parser';
 import traverse from '@babel/traverse';
-import { d as defu } from './defu-NLkZUlr9.mjs';
-import { n as noop, d as defaultOptions, i as isMap } from './defaults-dz6xGhOP.mjs';
+import { d as defuOverrideArray, n as noop, a as defaultOptions, i as isMap } from './defaults-TZpmwtzd.mjs';
 import * as t from '@babel/types';
 import { Parser } from 'htmlparser2';
 import postcss from 'postcss';
-import { p as postcssWeappTailwindcss } from './postcss-W8i3cl5I.mjs';
-import postcssIsPseudoClass from '@csstools/postcss-is-pseudo-class';
+import { g as getPlugins } from './postcss-kpIT_QQe.mjs';
 import path from 'node:path';
 import fs from 'node:fs';
 import { gte } from 'semver';
@@ -63,33 +60,6 @@ const splitCode = (code, allowDoubleQuotes = false) => {
     return code.split(splitter).filter((element) => isValidSelector(element));
 };
 
-function regenerateHandleValue(str, node, options) {
-    var _a;
-    const set = options.classNameSet;
-    const escapeMap = options.escapeMap;
-    const allowDoubleQuotes = (_a = options.arbitraryValues) === null || _a === void 0 ? void 0 : _a.allowDoubleQuotes;
-    const ctx = options.mangleContext;
-    const jsPreserveClass = options.jsPreserveClass;
-    const arr = splitCode(str, allowDoubleQuotes);
-    let rawStr = str;
-    for (const v of arr) {
-        if (set.has(v) && !(jsPreserveClass === null || jsPreserveClass === void 0 ? void 0 : jsPreserveClass(v))) {
-            let ignoreFlag = false;
-            if (Array.isArray(node.leadingComments)) {
-                ignoreFlag = node.leadingComments.findIndex((x) => x.value.includes('weapp-tw') && x.value.includes('ignore')) > -1;
-            }
-            if (!ignoreFlag) {
-                if (ctx) {
-                    rawStr = ctx.jsHandler(rawStr);
-                }
-                rawStr = rawStr.replaceAll(new RegExp(escapeStringRegexp(v), 'g'), replaceWxml(v, {
-                    escapeMap
-                }));
-            }
-        }
-    }
-    return rawStr;
-}
 function replaceHandleValue(str, node, options, ms, offset = 0, needEscaped = false) {
     var _a;
     const set = options.classNameSet;
@@ -126,8 +96,6 @@ function replaceHandleValue(str, node, options, ms, offset = 0, needEscaped = fa
     return rawStr;
 }
 
-const isProd = () => process.env.NODE_ENV === 'production';
-
 function isEvalPath(p) {
     if (p.isCallExpression()) {
         const calleePath = p.get('callee');
@@ -136,149 +104,94 @@ function isEvalPath(p) {
     return false;
 }
 function jsHandler(rawSource, options) {
-    var _a;
     let ast;
     try {
         ast = parse(rawSource, {
             sourceType: 'unambiguous'
         });
     }
-    catch (_b) {
+    catch (_a) {
         return {
             code: rawSource
         };
     }
-    if (options.strategy === 'replace') {
-        const ms = new MagicString(rawSource);
-        const ropt = {
-            StringLiteral: {
-                enter(p) {
-                    var _a;
-                    if (isEvalPath(p.parentPath)) {
-                        return;
-                    }
-                    const n = p.node;
-                    replaceHandleValue(n.value, n, options, ms, 1, (_a = options.needEscaped) !== null && _a !== void 0 ? _a : true);
+    const ms = new MagicString(rawSource);
+    const ropt = {
+        StringLiteral: {
+            enter(p) {
+                var _a;
+                if (isEvalPath(p.parentPath)) {
+                    return;
                 }
-            },
-            TemplateElement: {
-                enter(p) {
-                    if (p.parentPath.isTemplateLiteral() && isEvalPath(p.parentPath.parentPath)) {
-                        return;
-                    }
-                    const n = p.node;
-                    replaceHandleValue(n.value.raw, n, options, ms, 0, false);
+                const n = p.node;
+                replaceHandleValue(n.value, n, options, ms, 1, (_a = options.needEscaped) !== null && _a !== void 0 ? _a : true);
+            }
+        },
+        TemplateElement: {
+            enter(p) {
+                if (p.parentPath.isTemplateLiteral() && isEvalPath(p.parentPath.parentPath)) {
+                    return;
                 }
-            },
-            CallExpression: {
-                enter(p) {
-                    if (isEvalPath(p)) {
-                        p.traverse({
-                            StringLiteral: {
-                                enter(s) {
-                                    const res = jsHandler(s.node.value, Object.assign(Object.assign({}, options), { needEscaped: false, generateMap: false }));
-                                    if (res.code) {
-                                        const node = s.node;
-                                        if (typeof node.start === 'number' && typeof node.end === 'number') {
-                                            const start = node.start + 1;
-                                            const end = node.end - 1;
-                                            if (start < end && s.node.value !== res.code) {
-                                                ms.update(start, end, jsStringEscape(res.code));
-                                                node.value = res.code;
-                                            }
-                                        }
-                                    }
-                                }
-                            },
-                            TemplateElement: {
-                                enter(s) {
-                                    const res = jsHandler(s.node.value.raw, Object.assign(Object.assign({}, options), { generateMap: false }));
-                                    if (res.code) {
-                                        const node = s.node;
-                                        if (typeof node.start === 'number' && typeof node.end === 'number') {
-                                            const start = node.start;
-                                            const end = node.end;
-                                            if (start < end && s.node.value.raw !== res.code) {
-                                                ms.update(start, end, res.code);
-                                                s.node.value.raw = res.code;
-                                            }
+                const n = p.node;
+                replaceHandleValue(n.value.raw, n, options, ms, 0, false);
+            }
+        },
+        CallExpression: {
+            enter(p) {
+                if (isEvalPath(p)) {
+                    p.traverse({
+                        StringLiteral: {
+                            enter(s) {
+                                const res = jsHandler(s.node.value, Object.assign(Object.assign({}, options), { needEscaped: false, generateMap: false }));
+                                if (res.code) {
+                                    const node = s.node;
+                                    if (typeof node.start === 'number' && typeof node.end === 'number') {
+                                        const start = node.start + 1;
+                                        const end = node.end - 1;
+                                        if (start < end && s.node.value !== res.code) {
+                                            ms.update(start, end, jsStringEscape(res.code));
+                                            node.value = res.code;
                                         }
                                     }
                                 }
                             }
-                        });
-                    }
-                }
-            }
-        };
-        traverse(ast, ropt);
-        const result = {
-            code: ms.toString()
-        };
-        return result;
-    }
-    else {
-        const gopt = {
-            StringLiteral: {
-                enter(p) {
-                    if (isEvalPath(p.parentPath)) {
-                        return;
-                    }
-                    const n = p.node;
-                    n.value = regenerateHandleValue(n.value, n, options);
-                }
-            },
-            TemplateElement: {
-                enter(p) {
-                    if (p.parentPath.isTemplateLiteral() && isEvalPath(p.parentPath.parentPath)) {
-                        return;
-                    }
-                    const n = p.node;
-                    n.value.raw = regenerateHandleValue(n.value.raw, n, options);
-                }
-            },
-            CallExpression: {
-                enter(p) {
-                    if (isEvalPath(p)) {
-                        p.traverse({
-                            StringLiteral: {
-                                enter(s) {
-                                    const res = jsHandler(s.node.value, options);
-                                    if (res.code) {
-                                        s.node.value = res.code;
-                                    }
-                                }
-                            },
-                            TemplateElement: {
-                                enter(s) {
-                                    const res = jsHandler(s.node.value.raw, options);
-                                    if (res.code) {
-                                        s.node.value.raw = res.code;
+                        },
+                        TemplateElement: {
+                            enter(s) {
+                                const res = jsHandler(s.node.value.raw, Object.assign(Object.assign({}, options), { generateMap: false }));
+                                if (res.code) {
+                                    const node = s.node;
+                                    if (typeof node.start === 'number' && typeof node.end === 'number') {
+                                        const start = node.start;
+                                        const end = node.end;
+                                        if (start < end && s.node.value.raw !== res.code) {
+                                            ms.update(start, end, res.code);
+                                            s.node.value.raw = res.code;
+                                        }
                                     }
                                 }
                             }
-                        });
-                    }
+                        }
+                    });
                 }
             }
-        };
-        traverse(ast, gopt);
-        return generate(ast, {
-            minified: (_a = options.minifiedJs) !== null && _a !== void 0 ? _a : isProd()
-        });
-    }
+        }
+    };
+    traverse(ast, ropt);
+    const result = {
+        code: ms.toString()
+    };
+    return result;
 }
 function createJsHandler(options) {
-    const { mangleContext, arbitraryValues, minifiedJs, escapeMap, jsPreserveClass, strategy, generateMap } = options;
+    const { mangleContext, arbitraryValues, escapeMap, jsPreserveClass, generateMap } = options;
     return (rawSource, set, options) => {
-        const opts = defu(options, {
+        const opts = defuOverrideArray(options, {
             classNameSet: set,
-            minifiedJs,
             escapeMap,
             arbitraryValues,
             mangleContext,
             jsPreserveClass,
-            strategy,
             generateMap
         });
         return jsHandler(rawSource, opts);
@@ -286,8 +199,7 @@ function createJsHandler(options) {
 }
 
 function getQuotes(quote) {
-    const quotes = quote === "'" ? 'double' : 'single';
-    return quotes;
+    return quote === "'" ? 'double' : 'single';
 }
 function generateCode(match, options = {}) {
     const ast = parseExpression(match);
@@ -445,20 +357,18 @@ function customTemplateHandler(rawSource, options) {
 }
 function createTemplateHandler(options = {}) {
     return (rawSource, opt = {}) => {
-        return customTemplateHandler(rawSource, defu(opt, options));
+        return customTemplateHandler(rawSource, defuOverrideArray(opt, options));
     };
 }
 
 function styleHandler(rawSource, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        return (yield postcss([postcssIsPseudoClass(), postcssWeappTailwindcss(options)])
-            .process(rawSource)
-            .async()).css;
+        return (yield postcss(getPlugins(options)).process(rawSource).async()).css;
     });
 }
 function createStyleHandler(options) {
     return (rawSource, opt) => {
-        return styleHandler(rawSource, defu(opt, options));
+        return styleHandler(rawSource, defuOverrideArray(opt, options));
     };
 }
 
@@ -728,62 +638,37 @@ function createCache() {
     };
 }
 
-function createGlobMatcher(pattern) {
-    return function (file) {
-        return isMatch(file, pattern);
-    };
-}
-function normalizeMatcher(options, key) {
-    if (typeof options[key] === 'string' || Array.isArray(options[key])) {
-        options[key] = createGlobMatcher(options[key]);
-    }
-}
 function getOptions(options = {}) {
-    if (options.supportCustomLengthUnitsPatch === true) {
-        options.supportCustomLengthUnitsPatch = undefined;
-    }
     if (options.customReplaceDictionary === undefined || options.customReplaceDictionary === 'simple') {
         options.customReplaceDictionary = SimpleMappingChars2String;
     }
-    else if (options.customReplaceDictionary === 'complex') {
-        options.customReplaceDictionary = MappingChars2String;
-    }
-    normalizeMatcher(options, 'cssMatcher');
-    normalizeMatcher(options, 'htmlMatcher');
-    normalizeMatcher(options, 'jsMatcher');
-    normalizeMatcher(options, 'wxsMatcher');
-    normalizeMatcher(options, 'mainCssChunkMatcher');
-    const result = defu(options, defaultOptions, {
-        minifiedJs: isProd()
-    });
-    const { cssPreflight, customRuleCallback, cssPreflightRange, replaceUniversalSelectorWith, customAttributes, customReplaceDictionary, supportCustomLengthUnitsPatch, arbitraryValues, cssChildCombinatorReplaceValue, inlineWxs, injectAdditionalCssVarScope, jsPreserveClass, disabledDefaultTemplateHandler, jsEscapeStrategy, cssSelectorReplacement } = result;
+    const result = defuOverrideArray(options, defaultOptions, {});
+    const { cssPreflight, customRuleCallback, cssPreflightRange, customAttributes, customReplaceDictionary, supportCustomLengthUnitsPatch, arbitraryValues, cssChildCombinatorReplaceValue, inlineWxs, injectAdditionalCssVarScope, jsPreserveClass, disabledDefaultTemplateHandler, cssSelectorReplacement, rem2rpx } = result;
     result.escapeMap = customReplaceDictionary;
     const cssInjectPreflight = createInjectPreflight(cssPreflight);
     const customAttributesEntities = isMap(options.customAttributes)
         ? [...options.customAttributes.entries()]
         : Object.entries(customAttributes);
-    const { escapeMap, minifiedJs } = result;
+    const { escapeMap } = result;
     const { initMangle, mangleContext, setMangleRuntimeSet } = useMangleStore();
     initMangle(options.mangle);
     const styleHandler = createStyleHandler({
         cssInjectPreflight,
         customRuleCallback,
         cssPreflightRange,
-        replaceUniversalSelectorWith,
         escapeMap,
         mangleContext,
         cssChildCombinatorReplaceValue,
         injectAdditionalCssVarScope,
-        cssSelectorReplacement
+        cssSelectorReplacement,
+        rem2rpx
     });
     result.styleHandler = styleHandler;
     const jsHandler = createJsHandler({
-        minifiedJs,
         escapeMap,
         mangleContext,
         arbitraryValues,
         jsPreserveClass,
-        strategy: jsEscapeStrategy,
         generateMap: true
     });
     result.jsHandler = jsHandler;

package/dist/postcss/mp.d.ts

@@ -3,6 +3,6 @@ import type { IStyleHandlerOptions } from "../types";
 export declare function testIfVariablesScope(node: Rule, count?: number): boolean;
 export declare function testIfTwBackdrop(node: Rule, count?: number): boolean;
 export declare function makePseudoVarRule(): Rule;
-export declare function remakeCssVarSelector(selectors: string[], cssPreflightRange: IStyleHandlerOptions['cssPreflightRange']): string[];
+export declare function remakeCssVarSelector(selectors: string[], options: IStyleHandlerOptions): string[];
 export declare function remakeCombinatorSelector(selector: string, cssChildCombinatorReplaceValue: IStyleHandlerOptions['cssChildCombinatorReplaceValue']): string;
 export declare function commonChunkPreflight(node: Rule, options: IStyleHandlerOptions): void;

package/dist/postcss/plugins/ctx.d.ts

@@ -0,0 +1,4 @@
+export declare function createContext(): {
+    variablesScopeWeakMap: WeakMap<object, any>;
+};
+export type IContext = ReturnType<typeof createContext>;

package/dist/postcss/plugins/index.d.ts

@@ -0,0 +1,7 @@
+import { AcceptedPlugin } from 'postcss';
+import { IStyleHandlerOptions } from "../../types";
+export declare function getPlugins(options: IStyleHandlerOptions): AcceptedPlugin[];
+export { postcssWeappTailwindcssPostPlugin } from './post';
+export { postcssWeappTailwindcssPrePlugin } from './pre';
+export { default as postcssIsPseudoClass } from '@csstools/postcss-is-pseudo-class';
+export { default as postcssRem2rpx } from 'postcss-rem-to-responsive-pixel';

package/dist/postcss/plugins/post.d.ts

@@ -0,0 +1,5 @@
+import type { PluginCreator } from 'postcss';
+import type { IStyleHandlerOptions } from "../../types";
+export type PostcssWeappTailwindcssRenamePlugin = PluginCreator<IStyleHandlerOptions>;
+declare const postcssWeappTailwindcssPostPlugin: PostcssWeappTailwindcssRenamePlugin;
+export { postcssWeappTailwindcssPostPlugin };

package/dist/postcss/plugins/pre.d.ts

@@ -0,0 +1,5 @@
+import type { PluginCreator } from 'postcss';
+import type { IStyleHandlerOptions } from "../../types";
+export type PostcssWeappTailwindcssRenamePlugin = PluginCreator<IStyleHandlerOptions>;
+declare const postcssWeappTailwindcssPrePlugin: PostcssWeappTailwindcssRenamePlugin;
+export { postcssWeappTailwindcssPrePlugin };

package/dist/postcss/shared.d.ts

@@ -1,2 +1,3 @@
 import { InternalCssSelectorReplacerOptions } from "../types";
 export declare function internalCssSelectorReplacer(selectors: string, options?: InternalCssSelectorReplacerOptions): string;
+export declare function composeIsPseudo(strs: string | string[]): string;

package/dist/postcss/symbols.d.ts

@@ -0,0 +1 @@
+export declare const VariablesScopeSymbol: unique symbol;