weapp-tailwindcss 2.3.3

package/dist/options-ed6f4a3a.mjs

@@ -0,0 +1,542 @@
+import { m as makeCustomAttributes, t as tagWithEitherClassAndHoverClassRegexp, a as templateClassExactRegexp, v as variableMatch, b as variableRegExp, n as noop, s as splitCode, e as escapeStringRegexp, u as useStore, S as SimpleMappingChars2String, M as MappingChars2String, i as isMap } from './shared-eae1dc7a.mjs';
+import { isMatch } from 'micromatch';
+import generate from '@babel/generator';
+import { parseExpression, parse } from '@babel/parser';
+import traverse from '@babel/traverse';
+import { replaceJs as replaceWxml } from './replace.mjs';
+import * as t from '@babel/types';
+import postcss from 'postcss';
+import { p as postcssWeappTailwindcss } from './postcss-1f9a5153.mjs';
+import postcssIsPseudoClass from '@csstools/postcss-is-pseudo-class';
+import path from 'path';
+import fs from 'fs';
+import { gte } from 'semver';
+import { monkeyPatchForExposingContext, requireResolve, TailwindcssPatcher } from 'tailwindcss-patch';
+
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isObject(value) && isObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+const defu = createDefu();
+
+function generateCode(match, options = {}) {
+    const ast = parseExpression(match);
+    traverse(ast, {
+        StringLiteral(path) {
+            var _a;
+            if (t.isMemberExpression(path.parent)) {
+                return;
+            }
+            if (t.isBinaryExpression(path.parent)) {
+                if (t.isConditionalExpression((_a = path.parentPath) === null || _a === void 0 ? void 0 : _a.parent)) {
+                    return;
+                }
+            }
+            path.node.value = replaceWxml(path.node.value, options);
+        },
+        noScope: true
+    });
+    const { code } = generate(ast, {
+        compact: true,
+        minified: true,
+        jsescOption: {
+            quotes: 'single',
+            minimal: true
+        }
+    });
+    return code;
+}
+function extractSource(original) {
+    let match = variableMatch(original);
+    const sources = [];
+    while (match !== null) {
+        const start = match.index;
+        const end = variableRegExp.lastIndex;
+        sources.push({
+            start,
+            end,
+            raw: match[1],
+            prevConcatenated: !/\s/.test(original[start - 1]),
+            nextConcatenated: !/\s/.test(original[end])
+        });
+        match = variableMatch(original);
+    }
+    return sources;
+}
+function templeteReplacer(original, options = {}) {
+    const sources = extractSource(original);
+    if (sources.length) {
+        const resultArray = [];
+        let p = 0;
+        for (let i = 0; i < sources.length; i++) {
+            const m = sources[i];
+            const before = original.slice(p, m.start);
+            resultArray.push(replaceWxml(before, {
+                keepEOL: true,
+                escapeMap: options.escapeMap
+            }));
+            p = m.start;
+            if (m.raw.trim().length) {
+                const code = generateCode(m.raw, options);
+                const source = `{{${code}}}`;
+                m.source = source;
+            }
+            else {
+                m.source = '';
+            }
+            resultArray.push(m.source);
+            p = m.end;
+            if (i === sources.length - 1) {
+                const after = original.slice(m.end);
+                resultArray.push(replaceWxml(after, {
+                    keepEOL: true,
+                    escapeMap: options.escapeMap
+                }));
+            }
+        }
+        return resultArray
+            .filter((x) => x)
+            .join('')
+            .trim();
+    }
+    else {
+        return replaceWxml(original, {
+            keepEOL: false,
+            escapeMap: options.escapeMap
+        });
+    }
+}
+function templeteHandler(rawSource, options = {}) {
+    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 = makeCustomAttributes(options.customAttributesEntities);
+    if (regexps) {
+        if (Array.isArray(regexps)) {
+            for (let i = 0; i < regexps.length; i++) {
+                const regexp = regexps[i];
+                source = source.replace(regexp.tagRegexp, (m0) => {
+                    return m0.replace(regexp.attrRegexp, (m1, className) => {
+                        return m1.replace(className, templeteReplacer(className, options));
+                    });
+                });
+            }
+        }
+        return source;
+    }
+    else {
+        return source;
+    }
+}
+function createTempleteHandler(options = {}) {
+    return (rawSource, opt = {}) => {
+        return customTempleteHandler(rawSource, defu(opt, options));
+    };
+}
+
+function styleHandler(rawSource, options) {
+    return postcss([postcssWeappTailwindcss(options), postcssIsPseudoClass()]).process(rawSource).css;
+}
+function createStyleHandler(options) {
+    return (rawSource, opt) => {
+        return styleHandler(rawSource, defu(opt, options));
+    };
+}
+
+const createInjectPreflight = (options) => {
+    const result = [];
+    if (options && typeof options === 'object') {
+        const entries = Object.entries(options);
+        for (let i = 0; i < entries.length; i++) {
+            const [prop, value] = entries[i];
+            if (value !== false) {
+                result.push({
+                    prop,
+                    value: value.toString()
+                });
+            }
+        }
+    }
+    return () => {
+        return result;
+    };
+};
+
+function findAstNode(content, options) {
+    const DOPTS = options.dangerousOptions;
+    const ast = parse(content);
+    let arrayRef;
+    let changed = false;
+    traverse(ast, {
+        Identifier(path) {
+            if (path.node.name === DOPTS.variableName) {
+                if (t.isVariableDeclarator(path.parent)) {
+                    if (t.isArrayExpression(path.parent.init)) {
+                        arrayRef = path.parent.init;
+                        const set = new Set(path.parent.init.elements.map((x) => x.value));
+                        for (let i = 0; i < options.units.length; i++) {
+                            const unit = options.units[i];
+                            if (!set.has(unit)) {
+                                path.parent.init.elements = path.parent.init.elements.map((x) => {
+                                    if (t.isStringLiteral(x)) {
+                                        return {
+                                            type: x === null || x === void 0 ? void 0 : x.type,
+                                            value: x === null || x === void 0 ? void 0 : x.value
+                                        };
+                                    }
+                                    return x;
+                                });
+                                path.parent.init.elements.push({
+                                    type: 'StringLiteral',
+                                    value: unit
+                                });
+                                changed = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    });
+    return {
+        arrayRef,
+        changed
+    };
+}
+
+function getInstalledPkgJsonPath(options) {
+    const dangerousOptions = options.dangerousOptions;
+    try {
+        const tmpJsonPath = requireResolve(`${dangerousOptions.packageName}/package.json`, {
+            paths: options.paths,
+            basedir: options.basedir
+        });
+        return tmpJsonPath;
+    }
+    catch (error) {
+        if (error.code === 'MODULE_NOT_FOUND') {
+            console.warn('没有找到`tailwindcss`包，请确认是否安装。想要禁用打上rpx支持patch或者非`tailwindcss`框架，你可以设置 `supportCustomLengthUnitsPatch` 为 false');
+        }
+    }
+}
+function createPatch(options) {
+    if (options === false) {
+        return noop;
+    }
+    return () => {
+        try {
+            return internalPatch(getInstalledPkgJsonPath(options), options);
+        }
+        catch (error) {
+            console.warn(`patch tailwindcss failed:` + error.message);
+        }
+    };
+}
+function monkeyPatchForSupportingCustomUnit(rootDir, options) {
+    var _a;
+    const { dangerousOptions } = options;
+    const DOPTS = dangerousOptions;
+    const dataTypesFilePath = path.resolve(rootDir, DOPTS.lengthUnitsFilePath);
+    const dataTypesFileContent = fs.readFileSync(dataTypesFilePath, {
+        encoding: 'utf-8'
+    });
+    const { arrayRef, changed } = findAstNode(dataTypesFileContent, options);
+    if (arrayRef && changed) {
+        const { code } = generate(arrayRef, {
+            jsescOption: {
+                quotes: 'single'
+            }
+        });
+        if (arrayRef.start && arrayRef.end) {
+            const prev = dataTypesFileContent.slice(0, arrayRef.start);
+            const next = dataTypesFileContent.slice(arrayRef.end);
+            const newCode = prev + code + next;
+            if (DOPTS.overwrite) {
+                fs.writeFileSync((_a = DOPTS.destPath) !== null && _a !== void 0 ? _a : dataTypesFilePath, newCode, {
+                    encoding: 'utf-8'
+                });
+                console.log('patch tailwindcss for custom length unit successfully!');
+            }
+        }
+        return code;
+    }
+}
+function internalPatch(pkgJsonPath, options, overwrite = true) {
+    if (pkgJsonPath) {
+        const pkgJson = require(pkgJsonPath);
+        const dangerousOptions = options.dangerousOptions;
+        if (gte(pkgJson.version, dangerousOptions.gteVersion)) {
+            const rootDir = path.dirname(pkgJsonPath);
+            const dataTypes = monkeyPatchForSupportingCustomUnit(rootDir, options);
+            const result = monkeyPatchForExposingContext(rootDir, {
+                overwrite
+            });
+            return Object.assign(Object.assign({}, result), { dataTypes });
+        }
+    }
+}
+function createTailwindcssPatcher() {
+    return new TailwindcssPatcher({
+        cache: true
+    });
+}
+
+const isProd = () => process.env.NODE_ENV === 'production';
+
+function handleValue(str, node, options) {
+    const set = options.classNameSet;
+    const escapeMap = options.escapeMap;
+    const arr = splitCode(str);
+    let rawStr = str;
+    for (let i = 0; i < arr.length; i++) {
+        const v = arr[i];
+        if (set.has(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) {
+                const { jsHandler } = useStore();
+                rawStr = jsHandler(rawStr);
+                rawStr = rawStr.replace(new RegExp(escapeStringRegexp(v), 'g'), replaceWxml(v, {
+                    escapeMap
+                }));
+            }
+        }
+    }
+    return rawStr;
+}
+function jsHandler(rawSource, options) {
+    var _a;
+    const ast = parse(rawSource, {
+        sourceType: 'unambiguous'
+    });
+    const topt = {
+        StringLiteral: {
+            enter(p) {
+                const n = p.node;
+                n.value = handleValue(n.value, n, options);
+            }
+        },
+        TemplateElement: {
+            enter(p) {
+                const n = p.node;
+                n.value.raw = handleValue(n.value.raw, n, options);
+            }
+        },
+        CallExpression: {
+            enter(p) {
+                const n = p.node;
+                if (t.isIdentifier(n.callee) && n.callee.name === 'eval') {
+                    if (t.isStringLiteral(n.arguments[0])) {
+                        const res = jsHandler(n.arguments[0].value, options);
+                        if (res.code) {
+                            n.arguments[0].value = res.code;
+                        }
+                    }
+                }
+            }
+        },
+        noScope: true
+    };
+    traverse(ast, topt);
+    return generate(ast, {
+        minified: (_a = options.minifiedJs) !== null && _a !== void 0 ? _a : isProd()
+    });
+}
+function createjsHandler(options) {
+    return (rawSource, set) => {
+        return jsHandler(rawSource, {
+            classNameSet: set,
+            minifiedJs: options.minifiedJs,
+            escapeMap: options.escapeMap
+        });
+    };
+}
+
+const defaultOptions = {
+    cssMatcher: (file) => /.+\.(?:wx|ac|jx|tt|q|c)ss$/.test(file),
+    htmlMatcher: (file) => /.+\.(?:(?:(?:wx|ax|jx|ks|tt|q)ml)|swan)$/.test(file),
+    jsMatcher: (file) => {
+        if (file.includes('node_modules')) {
+            return false;
+        }
+        return /.+\.[cm]?[jt]sx?$/.test(file);
+    },
+    mainCssChunkMatcher: (file, appType) => {
+        switch (appType) {
+            case 'uni-app': {
+                return /^common\/main/.test(file);
+            }
+            case 'uni-app-vite': {
+                return /^app/.test(file) || /^common\/main/.test(file);
+            }
+            case 'mpx': {
+                return /^app/.test(file);
+            }
+            case 'taro': {
+                return /^app/.test(file);
+            }
+            case 'remax': {
+                return /^app/.test(file);
+            }
+            case 'rax': {
+                return /^bundle/.test(file);
+            }
+            case 'native': {
+                return /^app/.test(file);
+            }
+            case 'kbone': {
+                return /^(?:common\/)?miniprogram-app/.test(file);
+            }
+            default: {
+                return true;
+            }
+        }
+    },
+    cssPreflight: {
+        'box-sizing': 'border-box',
+        'border-width': '0',
+        'border-style': 'solid',
+        'border-color': 'currentColor'
+    },
+    cssPreflightRange: 'view',
+    replaceUniversalSelectorWith: 'view',
+    disabled: false,
+    customRuleCallback: noop,
+    onLoad: noop,
+    onStart: noop,
+    onEnd: noop,
+    onUpdate: noop,
+    customAttributes: {},
+    customReplaceDictionary: SimpleMappingChars2String,
+    supportCustomLengthUnitsPatch: {
+        units: ['rpx'],
+        dangerousOptions: {
+            gteVersion: '3.0.0',
+            lengthUnitsFilePath: 'lib/util/dataTypes.js',
+            packageName: 'tailwindcss',
+            variableName: 'lengthUnits',
+            overwrite: true
+        }
+    },
+    appType: undefined
+};
+
+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 = {}, 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
+    });
+    if (options.supportCustomLengthUnitsPatch === true) {
+        options.supportCustomLengthUnitsPatch = undefined;
+    }
+    if (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, 'mainCssChunkMatcher');
+    const result = defu(options, defaultOptions, {
+        minifiedJs: isProd()
+    });
+    const { cssPreflight, customRuleCallback, cssPreflightRange, replaceUniversalSelectorWith, customAttributes, customReplaceDictionary, supportCustomLengthUnitsPatch } = result;
+    result.escapeMap = customReplaceDictionary;
+    const cssInjectPreflight = createInjectPreflight(cssPreflight);
+    let customAttributesEntities;
+    if (isMap(options.customAttributes)) {
+        customAttributesEntities = Array.from(options.customAttributes.entries());
+    }
+    else {
+        customAttributesEntities = Object.entries(customAttributes);
+    }
+    if (registerModules.templete) {
+        result.templeteHandler = createTempleteHandler({
+            customAttributesEntities,
+            escapeMap: result.escapeMap
+        });
+    }
+    if (registerModules.style) {
+        result.styleHandler = createStyleHandler({
+            cssInjectPreflight,
+            customRuleCallback,
+            cssPreflightRange,
+            replaceUniversalSelectorWith,
+            escapeMap: result.escapeMap
+        });
+    }
+    if (registerModules.js) {
+        result.jsHandler = createjsHandler({
+            minifiedJs: result.minifiedJs,
+            escapeMap: result.escapeMap
+        });
+    }
+    if (registerModules.patch) {
+        result.patch = createPatch(supportCustomLengthUnitsPatch);
+    }
+    return result;
+}
+
+export { createTailwindcssPatcher as a, createPatch as c, getOptions as g };

package/dist/options.d.ts

@@ -0,0 +1,4 @@
+import type { InternalUserDefinedOptions, UserDefinedOptions } from './types';
+type IModules = readonly ('js' | 'style' | 'templete' | 'patch')[];
+export declare function getOptions(options?: UserDefinedOptions, modules?: IModules): InternalUserDefinedOptions;
+export {};

package/dist/postcss/index.d.ts

@@ -0,0 +1,3 @@
+import type { IStyleHandlerOptions } from "../types";
+export declare function styleHandler(rawSource: string, options: IStyleHandlerOptions): string;
+export declare function createStyleHandler(options: Partial<IStyleHandlerOptions>): (rawSource: string, opt: IStyleHandlerOptions) => string;

package/dist/postcss/mp.d.ts

@@ -0,0 +1,4 @@
+import { Rule } from 'postcss';
+import type { IStyleHandlerOptions } from "../types";
+export declare function testIfVariablesScope(node: Rule, count?: number): boolean;
+export declare function commonChunkPreflight(node: Rule, options: IStyleHandlerOptions): void;

package/dist/postcss/plugin.d.ts

@@ -0,0 +1,6 @@
+import type { PluginCreator } from 'postcss';
+import type { IStyleHandlerOptions } from "../types";
+import postcssIsPseudoClass from '@csstools/postcss-is-pseudo-class';
+export type PostcssWeappTailwindcssRenamePlugin = PluginCreator<IStyleHandlerOptions>;
+declare const postcssWeappTailwindcss: PostcssWeappTailwindcssRenamePlugin;
+export { postcssWeappTailwindcss, postcssIsPseudoClass };

package/dist/postcss/preflight.d.ts

@@ -0,0 +1,3 @@
+import type { CssPreflightOptions, IPropValue } from "../types";
+export type InjectPreflight = () => IPropValue[];
+export declare const createInjectPreflight: (options?: CssPreflightOptions) => InjectPreflight;

package/dist/postcss/selectorParser.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'postcss';
+import type { IStyleHandlerOptions } from "../types";
+export declare const transformSync: (rule: Rule, options: IStyleHandlerOptions) => void;

package/dist/postcss/shared.d.ts

@@ -0,0 +1 @@
+export declare function internalCssSelectorReplacer(selectors: string, map?: Record<string, string>): string;

package/dist/postcss-1f9a5153.mjs

@@ -0,0 +1,105 @@
+import selectorParser from 'postcss-selector-parser';
+import { f as internalCssSelectorReplacer } from './shared-eae1dc7a.mjs';
+import { Rule, Declaration } from 'postcss';
+import '@csstools/postcss-is-pseudo-class';
+
+const createTransform = (rule, options) => {
+    const replaceFlag = options.replaceUniversalSelectorWith !== false;
+    const transform = (selectors) => {
+        selectors.walk((selector) => {
+            if (selector.type === 'universal' && replaceFlag) {
+                selector.value = options.replaceUniversalSelectorWith;
+            }
+            if (selector.type === 'selector') {
+                const node = selector.nodes.find((x) => x.type === 'pseudo' && x.value === ':hover');
+                node && selector.remove();
+            }
+            if (selector.type === 'class') {
+                selector.value = internalCssSelectorReplacer(selector.value, options.escapeMap);
+            }
+        });
+        if (selectors.length === 0) {
+            rule.remove();
+        }
+    };
+    return transform;
+};
+const getTransformer = (rule, options) => {
+    return selectorParser(createTransform(rule, options));
+};
+const transformSync = (rule, options) => {
+    const transformer = getTransformer(rule, options);
+    return transformer.transformSync(rule, {
+        lossless: false,
+        updateSelector: true
+    });
+};
+
+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 = 1) {
+    if (/:?:before/.test(node.selector) && /:?:after/.test(node.selector)) {
+        for (let i = 0; i < count; i++) {
+            const tryTestDecl = node.nodes[i];
+            if (tryTestDecl && tryTestDecl.type === 'decl' && tryTestDecl.prop.startsWith('--tw-')) {
+                continue;
+            }
+            else {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+function commonChunkPreflight(node, options) {
+    node.selector = node.selector.replace(BROAD_MATCH_GLOBAL_REGEXP, 'view + view');
+    if (testIfVariablesScope(node)) {
+        const selectorParts = node.selector.split(',');
+        if (!selectorParts.includes('view')) {
+            selectorParts.push('view');
+        }
+        if (options.cssPreflightRange === 'all') {
+            if (!selectorParts.includes(':not(not)')) {
+                selectorParts.push(':not(not)');
+            }
+        }
+        node.selector = selectorParts.join(',');
+        if (typeof options.cssInjectPreflight === 'function') {
+            node.append(...options.cssInjectPreflight());
+        }
+        const pseudoVarRule = new Rule({
+            selector: '::before,::after'
+        });
+        pseudoVarRule.append(new Declaration({
+            prop: '--tw-content',
+            value: '""'
+        }));
+        node.before(pseudoVarRule);
+    }
+}
+
+const NS = 'jsx-rename-loader';
+const postcssPlugin = 'postcss-weapp-tailwindcss-rename-plugin';
+const pluginName = 'weapp-tailwindcss-webpack-plugin';
+const vitePluginName = 'vite-plugin-uni-app-weapp-tailwindcss-adaptor';
+
+const postcssWeappTailwindcss = (options = {
+    isMainChunk: true
+}) => {
+    const { customRuleCallback, isMainChunk } = options;
+    const flag = typeof customRuleCallback === 'function';
+    return {
+        postcssPlugin,
+        Once(css) {
+            css.walkRules((rule) => {
+                transformSync(rule, options);
+                isMainChunk && commonChunkPreflight(rule, options);
+                flag && customRuleCallback(rule, options);
+            });
+        }
+    };
+};
+postcssWeappTailwindcss.postcss = true;
+
+export { NS as N, pluginName as a, postcssWeappTailwindcss as p, vitePluginName as v };