weapp-tailwindcss 2.3.3

package/dist/options-3a695e84.js

@@ -0,0 +1,574 @@
+'use strict';
+
+var shared = require('./shared-c2953d9d.js');
+var micromatch = require('micromatch');
+var generate = require('@babel/generator');
+var parser = require('@babel/parser');
+var traverse = require('@babel/traverse');
+var replace = require('./replace.js');
+var t = require('@babel/types');
+var postcss = require('postcss');
+var postcss$1 = require('./postcss-dc9eeafc.js');
+var postcssIsPseudoClass = require('@csstools/postcss-is-pseudo-class');
+var path = require('path');
+var fs = require('fs');
+var semver = require('semver');
+var tailwindcssPatch = require('tailwindcss-patch');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var generate__default = /*#__PURE__*/_interopDefaultCompat(generate);
+var traverse__default = /*#__PURE__*/_interopDefaultCompat(traverse);
+var t__namespace = /*#__PURE__*/_interopNamespaceCompat(t);
+var postcss__default = /*#__PURE__*/_interopDefaultCompat(postcss);
+var postcssIsPseudoClass__default = /*#__PURE__*/_interopDefaultCompat(postcssIsPseudoClass);
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+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 = parser.parseExpression(match);
+    traverse__default["default"](ast, {
+        StringLiteral(path) {
+            var _a;
+            if (t__namespace.isMemberExpression(path.parent)) {
+                return;
+            }
+            if (t__namespace.isBinaryExpression(path.parent)) {
+                if (t__namespace.isConditionalExpression((_a = path.parentPath) === null || _a === void 0 ? void 0 : _a.parent)) {
+                    return;
+                }
+            }
+            path.node.value = replace.replaceJs(path.node.value, options);
+        },
+        noScope: true
+    });
+    const { code } = generate__default["default"](ast, {
+        compact: true,
+        minified: true,
+        jsescOption: {
+            quotes: 'single',
+            minimal: true
+        }
+    });
+    return code;
+}
+function extractSource(original) {
+    let match = shared.variableMatch(original);
+    const sources = [];
+    while (match !== null) {
+        const start = match.index;
+        const end = shared.variableRegExp.lastIndex;
+        sources.push({
+            start,
+            end,
+            raw: match[1],
+            prevConcatenated: !/\s/.test(original[start - 1]),
+            nextConcatenated: !/\s/.test(original[end])
+        });
+        match = shared.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(replace.replaceJs(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(replace.replaceJs(after, {
+                    keepEOL: true,
+                    escapeMap: options.escapeMap
+                }));
+            }
+        }
+        return resultArray
+            .filter((x) => x)
+            .join('')
+            .trim();
+    }
+    else {
+        return replace.replaceJs(original, {
+            keepEOL: false,
+            escapeMap: options.escapeMap
+        });
+    }
+}
+function templeteHandler(rawSource, options = {}) {
+    return rawSource.replace(shared.tagWithEitherClassAndHoverClassRegexp, (m0) => {
+        return m0.replace(shared.templateClassExactRegexp, (m1, className) => {
+            return m1.replace(className, templeteReplacer(className, options));
+        });
+    });
+}
+function customTempleteHandler(rawSource, options = {}) {
+    let source = templeteHandler(rawSource, options);
+    const regexps = shared.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__default["default"]([postcss$1.postcssWeappTailwindcss(options), postcssIsPseudoClass__default["default"]()]).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 = parser.parse(content);
+    let arrayRef;
+    let changed = false;
+    traverse__default["default"](ast, {
+        Identifier(path) {
+            if (path.node.name === DOPTS.variableName) {
+                if (t__namespace.isVariableDeclarator(path.parent)) {
+                    if (t__namespace.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__namespace.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 = tailwindcssPatch.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 shared.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__default["default"].resolve(rootDir, DOPTS.lengthUnitsFilePath);
+    const dataTypesFileContent = fs__default["default"].readFileSync(dataTypesFilePath, {
+        encoding: 'utf-8'
+    });
+    const { arrayRef, changed } = findAstNode(dataTypesFileContent, options);
+    if (arrayRef && changed) {
+        const { code } = generate__default["default"](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__default["default"].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 (semver.gte(pkgJson.version, dangerousOptions.gteVersion)) {
+            const rootDir = path__default["default"].dirname(pkgJsonPath);
+            const dataTypes = monkeyPatchForSupportingCustomUnit(rootDir, options);
+            const result = tailwindcssPatch.monkeyPatchForExposingContext(rootDir, {
+                overwrite
+            });
+            return Object.assign(Object.assign({}, result), { dataTypes });
+        }
+    }
+}
+function createTailwindcssPatcher() {
+    return new tailwindcssPatch.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 = shared.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 } = shared.useStore();
+                rawStr = jsHandler(rawStr);
+                rawStr = rawStr.replace(new RegExp(shared.escapeStringRegexp(v), 'g'), replace.replaceJs(v, {
+                    escapeMap
+                }));
+            }
+        }
+    }
+    return rawStr;
+}
+function jsHandler(rawSource, options) {
+    var _a;
+    const ast = parser.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__namespace.isIdentifier(n.callee) && n.callee.name === 'eval') {
+                    if (t__namespace.isStringLiteral(n.arguments[0])) {
+                        const res = jsHandler(n.arguments[0].value, options);
+                        if (res.code) {
+                            n.arguments[0].value = res.code;
+                        }
+                    }
+                }
+            }
+        },
+        noScope: true
+    };
+    traverse__default["default"](ast, topt);
+    return generate__default["default"](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: shared.noop,
+    onLoad: shared.noop,
+    onStart: shared.noop,
+    onEnd: shared.noop,
+    onUpdate: shared.noop,
+    customAttributes: {},
+    customReplaceDictionary: shared.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 micromatch.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 = shared.SimpleMappingChars2String;
+    }
+    else if (options.customReplaceDictionary === 'complex') {
+        options.customReplaceDictionary = shared.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 (shared.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;
+}
+
+exports.createPatch = createPatch;
+exports.createTailwindcssPatcher = createTailwindcssPatcher;
+exports.getOptions = getOptions;