weapp-tailwindcss 3.3.7 → 3.4.0-alpha.1

package/dist/index-BKZH-Gxq.mjs

@@ -1,134 +0,0 @@
-import { g as getOptions, _ as __awaiter } from './options-BHJnjA_a.mjs';
-import { v as vitePluginName } from './index-BPzIdybK.mjs';
-import { g as getGroupedEntries } from './defaults-DUZZvtdg.mjs';
-import { c as createDebug } from './index-BEIjgKpF.mjs';
-
-const 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 || patch === void 0 ? void 0 : patch();
-    onLoad();
-    return {
-        name: vitePluginName,
-        enforce: 'post',
-        generateBundle(opt, bundle) {
-            return __awaiter(this, void 0, void 0, 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;
-                            }
-                        }, () => __awaiter(this, void 0, void 0, 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;
-                            }
-                        }, () => __awaiter(this, void 0, void 0, 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;
-                            }
-                        }, () => __awaiter(this, void 0, void 0, 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 as U };

package/dist/index-BPzIdybK.mjs

@@ -1,513 +0,0 @@
-import postcssIsPseudoClass from '@csstools/postcss-is-pseudo-class';
-import postcssRem2rpx from 'postcss-rem-to-responsive-pixel';
-import selectorParser from 'postcss-selector-parser';
-import { c as composeIsPseudo, i as internalCssSelectorReplacer } from './shared-DbJl6i6a.mjs';
-import { Declaration, Rule } from 'postcss';
-
-function createRuleTransform(rule, options) {
-    const { escapeMap, mangleContext, cssSelectorReplacement, cssRemoveHoverPseudoClass } = options;
-    const transform = (selectors) => {
-        selectors.walk((selector) => {
-            if (selector.type === 'universal' && cssSelectorReplacement && cssSelectorReplacement.universal) {
-                selector.value = composeIsPseudo(cssSelectorReplacement.universal);
-            }
-            if (cssRemoveHoverPseudoClass && selector.type === 'selector') {
-                const node = selector.nodes.find(x => x.type === 'pseudo' && x.value === ':hover');
-                node && selector.remove();
-            }
-            if (selector.type === 'pseudo'
-                && selector.value === ':root'
-                && cssSelectorReplacement
-                && cssSelectorReplacement.root) {
-                selector.value = composeIsPseudo(cssSelectorReplacement.root);
-            }
-            if (selector.type === 'class') {
-                selector.value = internalCssSelectorReplacer(selector.value, {
-                    escapeMap,
-                    mangleContext,
-                });
-            }
-        });
-        if (selectors.length === 0) {
-            rule.remove();
-        }
-    };
-    return transform;
-}
-function getRuleTransformer(rule, options) {
-    return selectorParser(createRuleTransform(rule, options));
-}
-function ruleTransformSync(rule, options) {
-    const transformer = getRuleTransformer(rule, options);
-    return transformer.transformSync(rule, {
-        lossless: false,
-        updateSelector: true,
-    });
-}
-function isOnlyBeforeAndAfterPseudoElement(node) {
-    let b = false;
-    let a = false;
-    selectorParser((selectors) => {
-        selectors.walkPseudos((s) => {
-            var _a;
-            if (((_a = s.parent) === null || _a === void 0 ? void 0 : _a.length) === 1) {
-                if (/^:?:before$/.test(s.value)) {
-                    b = true;
-                }
-                if (/^:?:after$/.test(s.value)) {
-                    a = true;
-                }
-            }
-        });
-    }).astSync(node);
-    return b && a;
-}
-const fallbackRemove = selectorParser((selectors) => {
-    selectors.walk((selector) => {
-        var _a, _b;
-        if (selector.type === 'universal') {
-            (_a = selector.parent) === null || _a === void 0 ? void 0 : _a.remove();
-        }
-        if (selector.type === 'pseudo' && selector.value === ':is') {
-            (_b = selector.parent) === null || _b === void 0 ? void 0 : _b.remove();
-        }
-    });
-});
-
-var cssVars = [
-    {
-        prop: '--tw-border-spacing-x',
-        value: '0',
-    },
-    {
-        prop: '--tw-border-spacing-y',
-        value: '0',
-    },
-    {
-        prop: '--tw-translate-x',
-        value: '0',
-    },
-    {
-        prop: '--tw-translate-y',
-        value: '0',
-    },
-    {
-        prop: '--tw-rotate',
-        value: '0',
-    },
-    {
-        prop: '--tw-skew-x',
-        value: '0',
-    },
-    {
-        prop: '--tw-skew-y',
-        value: '0',
-    },
-    {
-        prop: '--tw-scale-x',
-        value: '1',
-    },
-    {
-        prop: '--tw-scale-y',
-        value: '1',
-    },
-    {
-        prop: '--tw-pan-x',
-        value: ' ',
-    },
-    {
-        prop: '--tw-pan-y',
-        value: ' ',
-    },
-    {
-        prop: '--tw-pinch-zoom',
-        value: ' ',
-    },
-    {
-        prop: '--tw-scroll-snap-strictness',
-        value: 'proximity',
-    },
-    {
-        prop: '--tw-gradient-from-position',
-        value: ' ',
-    },
-    {
-        prop: '--tw-gradient-via-position',
-        value: ' ',
-    },
-    {
-        prop: '--tw-gradient-to-position',
-        value: ' ',
-    },
-    {
-        prop: '--tw-ordinal',
-        value: ' ',
-    },
-    {
-        prop: '--tw-slashed-zero',
-        value: ' ',
-    },
-    {
-        prop: '--tw-numeric-figure',
-        value: ' ',
-    },
-    {
-        prop: '--tw-numeric-spacing',
-        value: ' ',
-    },
-    {
-        prop: '--tw-numeric-fraction',
-        value: ' ',
-    },
-    {
-        prop: '--tw-ring-inset',
-        value: ' ',
-    },
-    {
-        prop: '--tw-ring-offset-width',
-        value: '0px',
-    },
-    {
-        prop: '--tw-ring-offset-color',
-        value: '#fff',
-    },
-    {
-        prop: '--tw-ring-color',
-        value: 'rgb(59 130 246 / 0.5)',
-    },
-    {
-        prop: '--tw-ring-offset-shadow',
-        value: '0 0 #0000',
-    },
-    {
-        prop: '--tw-ring-shadow',
-        value: '0 0 #0000',
-    },
-    {
-        prop: '--tw-shadow',
-        value: '0 0 #0000',
-    },
-    {
-        prop: '--tw-shadow-colored',
-        value: '0 0 #0000',
-    },
-    {
-        prop: '--tw-blur',
-        value: ' ',
-    },
-    {
-        prop: '--tw-brightness',
-        value: ' ',
-    },
-    {
-        prop: '--tw-contrast',
-        value: ' ',
-    },
-    {
-        prop: '--tw-grayscale',
-        value: ' ',
-    },
-    {
-        prop: '--tw-hue-rotate',
-        value: ' ',
-    },
-    {
-        prop: '--tw-invert',
-        value: ' ',
-    },
-    {
-        prop: '--tw-saturate',
-        value: ' ',
-    },
-    {
-        prop: '--tw-sepia',
-        value: ' ',
-    },
-    {
-        prop: '--tw-drop-shadow',
-        value: ' ',
-    },
-    {
-        prop: '--tw-backdrop-blur',
-        value: ' ',
-    },
-    {
-        prop: '--tw-backdrop-brightness',
-        value: ' ',
-    },
-    {
-        prop: '--tw-backdrop-contrast',
-        value: ' ',
-    },
-    {
-        prop: '--tw-backdrop-grayscale',
-        value: ' ',
-    },
-    {
-        prop: '--tw-backdrop-hue-rotate',
-        value: ' ',
-    },
-    {
-        prop: '--tw-backdrop-invert',
-        value: ' ',
-    },
-    {
-        prop: '--tw-backdrop-opacity',
-        value: ' ',
-    },
-    {
-        prop: '--tw-backdrop-saturate',
-        value: ' ',
-    },
-    {
-        prop: '--tw-backdrop-sepia',
-        value: ' ',
-    },
-    {
-        prop: '--tw-contain-size',
-        value: ' ',
-    },
-    {
-        prop: '--tw-contain-layout',
-        value: ' ',
-    },
-    {
-        prop: '--tw-contain-paint',
-        value: ' ',
-    },
-    {
-        prop: '--tw-contain-style',
-        value: ' ',
-    },
-];
-
-const initialNodes = cssVars.map((x) => {
-    return new Declaration({
-        prop: x.prop,
-        value: x.value,
-    });
-});
-const PATTERNS = [
-    /:not\(template\)\s*[~+]\s*:not\(template\)/.source,
-    /:not\(\[hidden\]\)\s*[~+]\s*:not\(\[hidden\]\)/.source,
-].join('|');
-const BROAD_MATCH_GLOBAL_REGEXP = new RegExp(PATTERNS, 'g');
-function testIfVariablesScope(node, count = 2) {
-    if (isOnlyBeforeAndAfterPseudoElement(node)) {
-        const nodes = node.nodes;
-        let c = 0;
-        for (const tryTestDecl of nodes) {
-            if (tryTestDecl && tryTestDecl.type === 'decl' && tryTestDecl.prop.startsWith('--tw-')) {
-                c++;
-            }
-            if (c >= count) {
-                return true;
-            }
-        }
-        return false;
-    }
-    return false;
-}
-function testIfTwBackdrop(node, count = 2) {
-    if (node.type === 'rule' && node.selector === '::backdrop') {
-        const nodes = node.nodes;
-        let c = 0;
-        for (const tryTestDecl of nodes) {
-            if (tryTestDecl && tryTestDecl.type === 'decl' && tryTestDecl.prop.startsWith('--tw-')) {
-                c++;
-            }
-            if (c >= count) {
-                return true;
-            }
-        }
-        return false;
-    }
-    return false;
-}
-function makePseudoVarRule() {
-    const pseudoVarRule = new Rule({
-        selector: '::before,::after',
-    });
-    pseudoVarRule.append(new Declaration({
-        prop: '--tw-content',
-        value: '""',
-    }));
-    return pseudoVarRule;
-}
-function remakeCssVarSelector(selectors, options) {
-    const { cssPreflightRange, cssSelectorReplacement } = options;
-    if (cssPreflightRange === 'all'
-        && !selectors.includes(':not(not)')) {
-        selectors.push(':not(not)');
-    }
-    if (cssSelectorReplacement) {
-        if (Array.isArray(cssSelectorReplacement.universal)) {
-            if (!cssSelectorReplacement.universal.every((x) => {
-                return selectors.includes(x);
-            })
-                && !selectors.includes('*')) {
-                selectors.unshift('*');
-            }
-        }
-        else if (typeof cssSelectorReplacement.universal === 'string'
-            && !selectors.includes(cssSelectorReplacement.universal)
-            && !selectors.includes('*')) {
-            selectors.unshift('*');
-        }
-    }
-    return selectors;
-}
-function remakeCombinatorSelector(selector, cssChildCombinatorReplaceValue) {
-    let childCombinatorReplaceValue = 'view + view';
-    if (Array.isArray(cssChildCombinatorReplaceValue) && cssChildCombinatorReplaceValue.length > 0) {
-        const x = composeIsPseudo(cssChildCombinatorReplaceValue);
-        childCombinatorReplaceValue = `${x} + ${x}`;
-    }
-    else if (typeof cssChildCombinatorReplaceValue === 'string') {
-        childCombinatorReplaceValue = cssChildCombinatorReplaceValue;
-    }
-    return selector.replaceAll(BROAD_MATCH_GLOBAL_REGEXP, childCombinatorReplaceValue);
-}
-function commonChunkPreflight(node, options) {
-    const { ctx, cssChildCombinatorReplaceValue, cssInjectPreflight, injectAdditionalCssVarScope } = options;
-    node.selector = remakeCombinatorSelector(node.selector, cssChildCombinatorReplaceValue);
-    if (testIfVariablesScope(node)) {
-        ctx === null || ctx === void 0 ? void 0 : ctx.markVariablesScope(node);
-        node.selectors = remakeCssVarSelector(node.selectors, options);
-        node.before(makePseudoVarRule());
-        if (typeof cssInjectPreflight === 'function') {
-            node.append(...cssInjectPreflight());
-        }
-    }
-    if (injectAdditionalCssVarScope && testIfTwBackdrop(node)) {
-        const syntheticRule = new Rule({
-            selectors: ['*', '::after', '::before'],
-            nodes: initialNodes,
-        });
-        syntheticRule.selectors = remakeCssVarSelector(syntheticRule.selectors, options);
-        node.before(syntheticRule);
-        node.before(makePseudoVarRule());
-        if (typeof cssInjectPreflight === 'function') {
-            syntheticRule.append(...cssInjectPreflight());
-        }
-    }
-}
-
-const postcssPlugin = 'postcss-weapp-tailwindcss-rename-plugin';
-const pluginName = 'weapp-tailwindcss-webpack-plugin';
-const vitePluginName = 'vite-plugin-uni-app-weapp-tailwindcss-adaptor';
-const WEAPP_TW_REQUIRED_NODE_VERSION = '16.6.0';
-
-function isAtMediaHover(atRule) {
-    return (/media\(\s*hover\s*:\s*hover\s*\)/.test(atRule.name)
-        || (atRule.name === 'media' && /\(\s*hover\s*:\s*hover\s*\)/.test(atRule.params)));
-}
-const postcssWeappTailwindcssPrePlugin = (options = {
-    isMainChunk: true,
-}) => {
-    const { isMainChunk } = options;
-    const p = {
-        postcssPlugin,
-        Rule(rule) {
-            ruleTransformSync(rule, options);
-        },
-        AtRule(atRule) {
-            if (isAtMediaHover(atRule)) {
-                if (atRule.nodes) {
-                    atRule.replaceWith(atRule.nodes);
-                }
-                else {
-                    atRule.remove();
-                }
-            }
-        },
-    };
-    if (isMainChunk) {
-        p.Once = (root) => {
-            root.walkRules((rule) => {
-                commonChunkPreflight(rule, options);
-            });
-        };
-    }
-    return p;
-};
-postcssWeappTailwindcssPrePlugin.postcss = true;
-
-const postcssWeappTailwindcssPostPlugin = (options = {
-    isMainChunk: true,
-}) => {
-    const { customRuleCallback, isMainChunk, ctx } = options;
-    const p = {
-        postcssPlugin,
-    };
-    if (isMainChunk) {
-        p.OnceExit = (root) => {
-            root.walkRules((rule) => {
-                if (ctx) {
-                    if (ctx.isVariablesScope(rule)) {
-                        fallbackRemove.transformSync(rule, {
-                            updateSelector: true,
-                            lossless: false,
-                        });
-                    }
-                }
-                else if (testIfVariablesScope(rule)) {
-                    fallbackRemove.transformSync(rule, {
-                        updateSelector: true,
-                        lossless: false,
-                    });
-                }
-            });
-        };
-    }
-    if (typeof customRuleCallback === 'function') {
-        p.Rule = (rule) => {
-            customRuleCallback(rule, options);
-        };
-    }
-    return p;
-};
-postcssWeappTailwindcssPostPlugin.postcss = true;
-
-const VariablesScopeSymbol = Symbol('VariablesScope');
-
-function createContext() {
-    const variablesScopeWeakMap = new WeakMap();
-    function isVariablesScope(rule) {
-        return variablesScopeWeakMap.get(rule) === VariablesScopeSymbol;
-    }
-    function markVariablesScope(rule) {
-        variablesScopeWeakMap.set(rule, VariablesScopeSymbol);
-    }
-    return {
-        variablesScopeWeakMap,
-        isVariablesScope,
-        markVariablesScope,
-    };
-}
-
-function getPlugins(options) {
-    var _a, _b;
-    const ctx = createContext();
-    options.ctx = ctx;
-    const plugins = [
-        ...((_b = (_a = options.postcssOptions) === null || _a === void 0 ? void 0 : _a.plugins) !== null && _b !== void 0 ? _b : []),
-        postcssWeappTailwindcssPrePlugin(options),
-        postcssIsPseudoClass({
-            specificityMatchingName: 'weapp-tw-ig',
-        }),
-    ];
-    if (options.rem2rpx) {
-        plugins.push(postcssRem2rpx(typeof options.rem2rpx === 'object'
-            ? options.rem2rpx
-            : {
-                rootValue: 32,
-                propList: ['*'],
-                transformUnit: 'rpx',
-            }));
-    }
-    plugins.push(postcssWeappTailwindcssPostPlugin(options));
-    return plugins;
-}
-
-export { WEAPP_TW_REQUIRED_NODE_VERSION as W, postcssWeappTailwindcssPrePlugin as a, pluginName as b, getPlugins as g, postcssWeappTailwindcssPostPlugin as p, vitePluginName as v };