weapp-tailwindcss 3.4.0-alpha.0 → 3.4.0-alpha.2

package/dist/index-DmzxhHCX.js

@@ -0,0 +1,136 @@
+'use strict';
+
+var options = require('./options-C-rvBixk.js');
+var index = require('./index-DwZHOkK3.js');
+var defaults = require('./defaults-DW-EahCC.js');
+var index$1 = require('./index-HC-Qkn0i.js');
+
+const debug = index$1.createDebug();
+function UnifiedViteWeappTailwindcssPlugin(options$1 = {}) {
+    const opts = options.getOptions(options$1);
+    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: index.vitePluginName,
+        enforce: 'post',
+        generateBundle(opt, bundle) {
+            return options.__awaiter(this, void 0, void 0, function* () {
+                debug('start');
+                onStart();
+                const entries = Object.entries(bundle);
+                const groupedEntries = defaults.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;
+                            }
+                        }, () => options.__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;
+                            }
+                        }, () => options.__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;
+                            }
+                        }, () => options.__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');
+            });
+        },
+    };
+}
+
+exports.UnifiedViteWeappTailwindcssPlugin = UnifiedViteWeappTailwindcssPlugin;

package/dist/index-DwZHOkK3.js

@@ -0,0 +1,526 @@
+'use strict';
+
+var postcssIsPseudoClass = require('@csstools/postcss-is-pseudo-class');
+var postcssRem2rpx = require('postcss-rem-to-responsive-pixel');
+var selectorParser = require('postcss-selector-parser');
+var shared = require('./shared-hzYeE1wX.js');
+var postcss = require('postcss');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var postcssIsPseudoClass__default = /*#__PURE__*/_interopDefaultCompat(postcssIsPseudoClass);
+var postcssRem2rpx__default = /*#__PURE__*/_interopDefaultCompat(postcssRem2rpx);
+var selectorParser__default = /*#__PURE__*/_interopDefaultCompat(selectorParser);
+
+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 = shared.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 = shared.composeIsPseudo(cssSelectorReplacement.root);
+            }
+            if (selector.type === 'class') {
+                selector.value = shared.internalCssSelectorReplacer(selector.value, {
+                    escapeMap,
+                    mangleContext,
+                });
+            }
+        });
+        if (selectors.length === 0) {
+            rule.remove();
+        }
+    };
+    return transform;
+}
+function getRuleTransformer(rule, options) {
+    return selectorParser__default["default"](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__default["default"]((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__default["default"]((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 postcss.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 postcss.Rule({
+        selector: '::before,::after',
+    });
+    pseudoVarRule.append(new postcss.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 = shared.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 postcss.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__default["default"]({
+            specificityMatchingName: 'weapp-tw-ig',
+        }),
+    ];
+    if (options.rem2rpx) {
+        plugins.push(postcssRem2rpx__default["default"](typeof options.rem2rpx === 'object'
+            ? options.rem2rpx
+            : {
+                rootValue: 32,
+                propList: ['*'],
+                transformUnit: 'rpx',
+            }));
+    }
+    plugins.push(postcssWeappTailwindcssPostPlugin(options));
+    return plugins;
+}
+
+exports.WEAPP_TW_REQUIRED_NODE_VERSION = WEAPP_TW_REQUIRED_NODE_VERSION;
+exports.getPlugins = getPlugins;
+exports.pluginName = pluginName;
+exports.postcssWeappTailwindcssPostPlugin = postcssWeappTailwindcssPostPlugin;
+exports.postcssWeappTailwindcssPrePlugin = postcssWeappTailwindcssPrePlugin;
+exports.vitePluginName = vitePluginName;

package/dist/index-HC-Qkn0i.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var _createDebug = require('debug');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var _createDebug__default = /*#__PURE__*/_interopDefaultCompat(_createDebug);
+
+const _debug = _createDebug__default["default"]('weapp-tw');
+function createDebug(prefix) {
+    function debug(formatter, ...args) {
+        return _debug(('') + formatter, ...args);
+    }
+    return debug;
+}
+
+exports.createDebug = createDebug;

package/dist/index.d.ts

@@ -1,17 +1,4 @@
-export { UnifiedWebpackPluginV5 } from './webpack.js';
-export { UnifiedViteWeappTailwindcssPlugin } from './vite.js';
-export { createPlugins } from './gulp.js';
-export { A as AppType, u as CreateJsHandlerOptions, b as CssPreflightOptions, C as CssPresetProps, c as CustomRuleCallback, l as IArbitraryValues, s as IBaseWebpackPlugin, o as ICommonReplaceOptions, g as ICustomAttributes, h as ICustomAttributesEntities, i as IJsHandlerOptions, k as IMangleOptions, n as IMangleScopeContext, a as IPropValue, e as IStyleHandlerOptions, p as ITemplateHandlerOptions, d as InternalCssSelectorReplacerOptions, t as InternalPatchResult, r as InternalPostcssOptions, q as InternalUserDefinedOptions, I as ItemOrItemArray, m as JsHandler, J as JsHandlerReplaceResult, f as JsHandlerResult, j as RawSource, R as RequiredStyleHandlerOptions, U as UserDefinedOptions } from './types-DSNuiOhH.js';
-import 'webpack';
-import 'vite';
-import 'node:stream';
-import 'postcss';
-import '@tailwindcss-mangle/shared';
-import 'magic-string';
-import '@babel/generator';
-import '@babel/parser';
-import 'postcss-rem-to-responsive-pixel';
-import 'postcss-load-config';
-import 'tailwindcss-patch';
-import 'node:buffer';
-import 'lru-cache';
+export * from './webpack';
+export * from './vite';
+export * from './gulp';
+export * from './types';