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

package/dist/index-BPzIdybK.mjs

@@ -0,0 +1,513 @@
+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 };

package/dist/index-DeW_zXzo.mjs

@@ -0,0 +1,124 @@
+import { g as getOptions, _ as __awaiter } from './options-7EjuAISl.mjs';
+import stream from 'node:stream';
+import { Buffer } from 'node:buffer';
+import { c as createDebug } from './index-BEIjgKpF.mjs';
+
+const debug = createDebug();
+const Transform = stream.Transform;
+function createPlugins(options = {}) {
+    const opts = getOptions(options);
+    const { templateHandler, styleHandler, patch, jsHandler, setMangleRuntimeSet, cache, twPatcher } = opts;
+    let runtimeSet = new Set();
+    patch === null || patch === void 0 ? void 0 : patch();
+    function transformWxss(options = {}) {
+        return new Transform({
+            objectMode: true,
+            transform(file, encoding, callback) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    runtimeSet = twPatcher.getClassSet();
+                    setMangleRuntimeSet(runtimeSet);
+                    const error = null;
+                    if (file.contents) {
+                        const rawSource = file.contents.toString();
+                        const hash = cache.computeHash(rawSource);
+                        cache.calcHashValueChanged(file.path, hash);
+                        yield cache.process(file.path, () => {
+                            const source = cache.get(file.path);
+                            if (source) {
+                                file.contents = Buffer.from(source);
+                                debug('css cache hit: %s', file.path);
+                            }
+                            else {
+                                return false;
+                            }
+                        }, () => __awaiter(this, void 0, void 0, function* () {
+                            const code = yield styleHandler(rawSource, Object.assign({ isMainChunk: true }, options));
+                            file.contents = Buffer.from(code);
+                            debug('css handle: %s', file.path);
+                            return {
+                                key: file.path,
+                                source: code,
+                            };
+                        }));
+                    }
+                    callback(error, file);
+                });
+            },
+        });
+    }
+    function transformJs(options = {}) {
+        return new Transform({
+            objectMode: true,
+            transform(file, encoding, callback) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const error = null;
+                    if (file.contents) {
+                        const rawSource = file.contents.toString();
+                        const hash = cache.computeHash(rawSource);
+                        cache.calcHashValueChanged(file.path, hash);
+                        yield cache.process(file.path, () => {
+                            const source = cache.get(file.path);
+                            if (source) {
+                                file.contents = Buffer.from(source);
+                                debug('js cache hit: %s', file.path);
+                            }
+                            else {
+                                return false;
+                            }
+                        }, () => __awaiter(this, void 0, void 0, function* () {
+                            const { code } = yield jsHandler(rawSource, runtimeSet, options);
+                            file.contents = Buffer.from(code);
+                            debug('js handle: %s', file.path);
+                            return {
+                                key: file.path,
+                                source: code,
+                            };
+                        }));
+                    }
+                    callback(error, file);
+                });
+            },
+        });
+    }
+    function transformWxml(options = {}) {
+        return new Transform({
+            objectMode: true,
+            transform(file, encoding, callback) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const error = null;
+                    if (file.contents) {
+                        const rawSource = file.contents.toString();
+                        const hash = cache.computeHash(rawSource);
+                        cache.calcHashValueChanged(file.path, hash);
+                        yield cache.process(file.path, () => {
+                            const source = cache.get(file.path);
+                            if (source) {
+                                file.contents = Buffer.from(source);
+                                debug('html cache hit: %s', file.path);
+                            }
+                            else {
+                                return false;
+                            }
+                        }, () => __awaiter(this, void 0, void 0, function* () {
+                            const code = yield templateHandler(rawSource, Object.assign({ runtimeSet }, options));
+                            file.contents = Buffer.from(code);
+                            debug('html handle: %s', file.path);
+                            return {
+                                key: file.path,
+                                source: code,
+                            };
+                        }));
+                    }
+                    callback(error, file);
+                });
+            },
+        });
+    }
+    return {
+        transformWxss,
+        transformWxml,
+        transformJs,
+    };
+}
+
+export { createPlugins as c };