tailwindcss-patch 0.0.0 → 0.0.1

package/README.md

@@ -1 +1,40 @@
-# tailwindcss-patch (WIP)
+# tailwindcss-patch
+
+get tailwindcss context at runtime!
+
+## Setup
+
+1. Install package
+
+```sh
+<yarn|npm|pnpm> add -D ts-patch
+```
+
+2. Patch tailwindcss
+
+```sh
+npx tw-patch
+```
+
+3. Add `prepare` script (keeps patch persisted after npm install)
+
+`package.json`
+
+```json
+{
+ /* ... */
+ "scripts": {
+   "prepare": "tw-patch"
+ }
+}
+```
+
+## Usage
+
+```js
+import { getContexts , getClassCacheSet } from 'tailwindcss-patch'
+// get all contexts at runtime
+getContexts() 
+// get all class generated by tailwindcss utilities
+getClassCacheSet()
+```

package/bin/tw-patch.js

@@ -1 +1,7 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
+const fs = require('fs')
+const path = require('path')
+const cliPath = path.resolve(__dirname, '../dist/cli.js')
+if (fs.existsSync(cliPath)) {
+  require(cliPath)
+}

package/dist/cli.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var patcher = require('./patcher-e9a851ca.js');
+require('path');
+require('fs');
+require('semver');
+require('@babel/types');
+require('@babel/generator');
+require('@babel/parser');
+require('@babel/traverse');
+
+const patch = patcher.createPatch({});
+patch();

package/dist/index.js

@@ -1,2 +1,56 @@
 'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var path = require('path');
+var fs = require('fs');
+var patcher = require('./patcher-e9a851ca.js');
+require('semver');
+require('@babel/types');
+require('@babel/generator');
+require('@babel/parser');
+require('@babel/traverse');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var path__default = /*#__PURE__*/_interopDefaultCompat(path);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+function getContexts() {
+    const distPath = path__default["default"].dirname(require.resolve('tailwindcss/lib'));
+    let injectFilePath = path__default["default"].join(distPath, 'plugin.js');
+    if (!fs__default["default"].existsSync(injectFilePath)) {
+        injectFilePath = path__default["default"].join(distPath, 'index.js');
+    }
+    const mo = require(injectFilePath);
+    if (mo.contextRef) {
+        return mo.contextRef.value;
+    }
+    return [];
+}
+function getClassCaches() {
+    const contexts = getContexts();
+    return contexts.map((x) => x.classCache);
+}
+function getClassCacheSet() {
+    const classCaches = getClassCaches();
+    const classSet = new Set();
+    for (let i = 0; i < classCaches.length; i++) {
+        const classCacheMap = classCaches[i];
+        const keys = classCacheMap.keys();
+        for (const key of keys) {
+            classSet.add(key);
+        }
+    }
+    return classSet;
+}
+
+exports.createPatch = patcher.createPatch;
+exports.getInstalledPkgJsonPath = patcher.getInstalledPkgJsonPath;
+exports.inspectPostcssPlugin = patcher.inspectPostcssPlugin;
+exports.inspectProcessTailwindFeaturesReturnContext = patcher.inspectProcessTailwindFeaturesReturnContext;
+exports.internalPatch = patcher.internalPatch;
+exports.monkeyPatchForExposingContext = patcher.monkeyPatchForExposingContext;
+exports.getClassCacheSet = getClassCacheSet;
+exports.getClassCaches = getClassCaches;
+exports.getContexts = getContexts;

package/dist/patcher-e9a851ca.js

@@ -0,0 +1,293 @@
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+var semver = require('semver');
+var t = require('@babel/types');
+var generate = require('@babel/generator');
+var parser = require('@babel/parser');
+var traverse = require('@babel/traverse');
+
+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 path__default = /*#__PURE__*/_interopDefaultCompat(path);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var t__namespace = /*#__PURE__*/_interopNamespaceCompat(t);
+var generate__default = /*#__PURE__*/_interopDefaultCompat(generate);
+var traverse__default = /*#__PURE__*/_interopDefaultCompat(traverse);
+
+function inspectProcessTailwindFeaturesReturnContext(content) {
+    const ast = parser.parse(content);
+    let hasPatched = false;
+    traverse__default["default"](ast, {
+        FunctionDeclaration(p) {
+            var _a, _b;
+            const n = p.node;
+            if (((_a = n.id) === null || _a === void 0 ? void 0 : _a.name) === 'processTailwindFeatures') {
+                if (n.body.body.length === 1 && n.body.body[0].type === 'ReturnStatement') {
+                    const rts = n.body.body[0];
+                    if (t__namespace.isFunctionExpression(rts.argument)) {
+                        const body = rts.argument.body.body;
+                        const lastStatement = body[body.length - 1];
+                        hasPatched = lastStatement.type === 'ReturnStatement' && ((_b = lastStatement.argument) === null || _b === void 0 ? void 0 : _b.type) === 'Identifier' && lastStatement.argument.name === 'context';
+                        if (!hasPatched) {
+                            const rts = t__namespace.returnStatement(t__namespace.identifier('context'));
+                            body.push(rts);
+                        }
+                    }
+                }
+            }
+        }
+    });
+    return {
+        code: hasPatched ? content : generate__default["default"](ast).code,
+        hasPatched
+    };
+}
+function inspectPostcssPlugin(content) {
+    const ast = parser.parse(content);
+    const exportKey = 'contextRef';
+    const variableName = 'contextRef';
+    const valueKey = 'value';
+    let hasPatched = false;
+    traverse__default["default"](ast, {
+        Program(p) {
+            const n = p.node;
+            const idx = n.body.findIndex((x) => {
+                var _a;
+                return (x.type === 'ExpressionStatement' &&
+                    x.expression.type === 'AssignmentExpression' &&
+                    x.expression.left.type === 'MemberExpression' &&
+                    x.expression.right.type === 'FunctionExpression' &&
+                    ((_a = x.expression.right.id) === null || _a === void 0 ? void 0 : _a.name) === 'tailwindcss');
+            });
+            if (idx > -1) {
+                const prevStatement = n.body[idx - 1];
+                const lastStatement = n.body[n.body.length - 1];
+                const hasPatchedCondition0 = prevStatement &&
+                    prevStatement.type === 'VariableDeclaration' &&
+                    prevStatement.declarations.length === 1 &&
+                    prevStatement.declarations[0].id.type === 'Identifier' &&
+                    prevStatement.declarations[0].id.name === variableName;
+                const hasPatchedCondition1 = lastStatement.type === 'ExpressionStatement' &&
+                    lastStatement.expression.type === 'AssignmentExpression' &&
+                    lastStatement.expression.right.type === 'Identifier' &&
+                    lastStatement.expression.right.name === variableName;
+                hasPatched = hasPatchedCondition0 || hasPatchedCondition1;
+                if (!hasPatched) {
+                    const statement = t__namespace.variableDeclaration('const', [
+                        t__namespace.variableDeclarator(t__namespace.identifier(variableName), t__namespace.objectExpression([t__namespace.objectProperty(t__namespace.identifier(valueKey), t__namespace.arrayExpression())]))
+                    ]);
+                    n.body.splice(idx, 0, statement);
+                    n.body.push(t__namespace.expressionStatement(t__namespace.assignmentExpression('=', t__namespace.memberExpression(t__namespace.memberExpression(t__namespace.identifier('module'), t__namespace.identifier('exports')), t__namespace.identifier(exportKey)), t__namespace.identifier(variableName))));
+                }
+            }
+        },
+        FunctionExpression(p) {
+            var _a, _b;
+            if (hasPatched) {
+                return;
+            }
+            const n = p.node;
+            if (((_a = n.id) === null || _a === void 0 ? void 0 : _a.name) === 'tailwindcss') {
+                if (n.body.body.length === 1 && n.body.body[0].type === 'ReturnStatement') {
+                    const returnStatement = n.body.body[0];
+                    if (((_b = returnStatement.argument) === null || _b === void 0 ? void 0 : _b.type) === 'ObjectExpression' && returnStatement.argument.properties.length === 2) {
+                        const properties = returnStatement.argument.properties;
+                        if (properties[0].type === 'ObjectProperty' && properties[1].type === 'ObjectProperty') {
+                            const keyMatched = properties[0].key.type === 'Identifier' && properties[0].key.name === 'postcssPlugin';
+                            const pluginsMatched = properties[1].key.type === 'Identifier' && properties[1].key.name === 'plugins';
+                            if (pluginsMatched &&
+                                keyMatched &&
+                                properties[1].value.type === 'CallExpression' &&
+                                properties[1].value.callee.type === 'MemberExpression' &&
+                                properties[1].value.callee.object.type === 'ArrayExpression') {
+                                const pluginsCode = properties[1].value.callee.object.elements;
+                                if (pluginsCode[1] && pluginsCode[1].type === 'FunctionExpression') {
+                                    const targetBlockStatement = pluginsCode[1].body;
+                                    const lastStatement = targetBlockStatement.body[targetBlockStatement.body.length - 1];
+                                    if (lastStatement.type === 'ExpressionStatement') {
+                                        const newExpressionStatement = t__namespace.expressionStatement(t__namespace.callExpression(t__namespace.memberExpression(t__namespace.memberExpression(t__namespace.identifier(variableName), t__namespace.identifier('value')), t__namespace.identifier('push')), [lastStatement.expression]));
+                                        targetBlockStatement.body[targetBlockStatement.body.length - 1] = newExpressionStatement;
+                                    }
+                                    const ifIdx = targetBlockStatement.body.findIndex((x) => x.type === 'IfStatement');
+                                    if (ifIdx > -1) {
+                                        const ifRoot = targetBlockStatement.body[ifIdx];
+                                        if (ifRoot.consequent.type === 'BlockStatement' && ifRoot.consequent.body[1] && ifRoot.consequent.body[1].type === 'ForOfStatement') {
+                                            const forOf = ifRoot.consequent.body[1];
+                                            if (forOf.body.type === 'BlockStatement' && forOf.body.body.length === 1 && forOf.body.body[0].type === 'IfStatement') {
+                                                const if2 = forOf.body.body[0];
+                                                if (if2.consequent.type === 'BlockStatement' && if2.consequent.body.length === 1 && if2.consequent.body[0].type === 'ExpressionStatement') {
+                                                    const target = if2.consequent.body[0];
+                                                    const newExpressionStatement = t__namespace.expressionStatement(t__namespace.callExpression(t__namespace.memberExpression(t__namespace.memberExpression(t__namespace.identifier(variableName), t__namespace.identifier('value')), t__namespace.identifier('push')), [target.expression]));
+                                                    if2.consequent.body[0] = newExpressionStatement;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    targetBlockStatement.body.unshift(t__namespace.expressionStatement(t__namespace.assignmentExpression('=', t__namespace.memberExpression(t__namespace.memberExpression(t__namespace.identifier(variableName), t__namespace.identifier(valueKey)), t__namespace.identifier('length')), t__namespace.numericLiteral(0))));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    });
+    return {
+        code: hasPatched ? content : generate__default["default"](ast).code,
+        hasPatched
+    };
+}
+
+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();
+
+const defaultOptions = {
+    overwrite: true
+};
+
+function ensureFileContent(filepaths) {
+    if (typeof filepaths === 'string') {
+        filepaths = [filepaths];
+    }
+    let content;
+    for (let i = 0; i < filepaths.length; i++) {
+        const filepath = filepaths[i];
+        if (fs__default["default"].existsSync(filepath)) {
+            content = fs__default["default"].readFileSync(filepath, {
+                encoding: 'utf-8'
+            });
+            break;
+        }
+    }
+    return content;
+}
+
+function getInstalledPkgJsonPath(options) {
+    try {
+        const tmpJsonPath = require.resolve(`tailwindcss/package.json`, {
+            paths: options.paths
+        });
+        const pkgJson = require(tmpJsonPath);
+        if (semver.gte(pkgJson.version, '3.0.0')) {
+            return tmpJsonPath;
+        }
+    }
+    catch (error) {
+        if (error.code === 'MODULE_NOT_FOUND') {
+            console.warn('没有找到`tailwindcss`包，请确认是否安装。');
+        }
+    }
+}
+function createPatch(options) {
+    const opt = defu(options, defaultOptions);
+    return () => {
+        try {
+            return internalPatch(getInstalledPkgJsonPath(options), opt);
+        }
+        catch (error) {
+            console.warn(`patch tailwindcss failed:` + error.message);
+        }
+    };
+}
+function monkeyPatchForExposingContext(rootDir, opt) {
+    const processTailwindFeaturesFilePath = path__default["default"].resolve(rootDir, 'lib/processTailwindFeatures.js');
+    const processTailwindFeaturesContent = ensureFileContent(processTailwindFeaturesFilePath);
+    const result = {};
+    if (processTailwindFeaturesContent) {
+        const { code, hasPatched } = inspectProcessTailwindFeaturesReturnContext(processTailwindFeaturesContent);
+        if (!hasPatched && opt.overwrite) {
+            fs__default["default"].writeFileSync(processTailwindFeaturesFilePath, code, {
+                encoding: 'utf-8'
+            });
+            console.log('patch tailwindcss processTailwindFeatures for return content successfully!');
+        }
+        result.processTailwindFeatures = code;
+    }
+    const pluginFilePath = path__default["default"].resolve(rootDir, 'lib/plugin.js');
+    const indexFilePath = path__default["default"].resolve(rootDir, 'lib/index.js');
+    const pluginContent = ensureFileContent([pluginFilePath, indexFilePath]);
+    if (pluginContent) {
+        const { code, hasPatched } = inspectPostcssPlugin(pluginContent);
+        if (!hasPatched && opt.overwrite) {
+            fs__default["default"].writeFileSync(pluginFilePath, code, {
+                encoding: 'utf-8'
+            });
+            console.log('patch tailwindcss for expose runtime content successfully!');
+        }
+        result.plugin = code;
+    }
+    return result;
+}
+function internalPatch(pkgJsonPath, options) {
+    if (pkgJsonPath) {
+        const rootDir = path__default["default"].dirname(pkgJsonPath);
+        const result = monkeyPatchForExposingContext(rootDir, options);
+        return result;
+    }
+}
+
+exports.createPatch = createPatch;
+exports.getInstalledPkgJsonPath = getInstalledPkgJsonPath;
+exports.inspectPostcssPlugin = inspectPostcssPlugin;
+exports.inspectProcessTailwindFeaturesReturnContext = inspectProcessTailwindFeaturesReturnContext;
+exports.internalPatch = internalPatch;
+exports.monkeyPatchForExposingContext = monkeyPatchForExposingContext;

package/dist/types/babel.d.ts

@@ -0,0 +1,4 @@
+import generate from '@babel/generator';
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
+export { generate, parse, traverse };

package/dist/types/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/defaults.d.ts

@@ -0,0 +1,2 @@
+import type { PatchOptions } from './type';
+export declare const defaultOptions: PatchOptions;

package/dist/types/exposeContext.d.ts

@@ -0,0 +1,8 @@
+import type { Rule } from 'postcss';
+export declare function getContexts(): any[];
+export declare function getClassCaches(): Map<string, ({
+    layer: string;
+    options: Record<string, any>;
+    sort: Record<string, any>;
+} | Rule)[]>[];
+export declare function getClassCacheSet(): Set<string>;

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './exposeContext';
+export * from './inspector';
+export * from './patcher';

package/dist/types/inspector.d.ts

@@ -0,0 +1,8 @@
+export declare function inspectProcessTailwindFeaturesReturnContext(content: string): {
+    code: string;
+    hasPatched: boolean;
+};
+export declare function inspectPostcssPlugin(content: string): {
+    code: string;
+    hasPatched: boolean;
+};

package/dist/types/patcher.d.ts

@@ -0,0 +1,8 @@
+import type { PatchOptions, InternalPatchOptions } from './type';
+export declare function getInstalledPkgJsonPath(options: PatchOptions): string | undefined;
+export declare function createPatch(options: PatchOptions): () => any;
+export declare function monkeyPatchForExposingContext(rootDir: string, opt: InternalPatchOptions): {
+    processTailwindFeatures?: string | undefined;
+    plugin?: string | undefined;
+};
+export declare function internalPatch(pkgJsonPath: string | undefined, options: InternalPatchOptions): any | undefined;

package/dist/types/type.d.ts

@@ -0,0 +1,8 @@
+export interface PatchOptions {
+    overwrite?: boolean;
+    paths?: string[];
+}
+export interface InternalPatchOptions {
+    overwrite: boolean;
+    paths?: string[];
+}

package/dist/types/utils.d.ts

@@ -0,0 +1 @@
+export declare function ensureFileContent(filepaths: string | string[]): string | undefined;

package/package.json

@@ -1,28 +1,51 @@
 {
   "name": "tailwindcss-patch",
-  "version": "0.0.0",
-  "description": "",
+  "version": "0.0.1",
+  "description": "patch tailwindcss for exposing context",
   "main": "dist/index.js",
-  "module": "dist/index.es.js",
   "types": "dist/types/index.d.ts",
   "bin": {
-    "tw-patch": "bin/tw-patch.js"
+    "tw-patch": "bin/tw-patch.js",
+    "tailwindcss-patch": "bin/tw-patch.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "bin"
   ],
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
+  "keywords": [
+    "tailwindcss",
+    "patch"
+  ],
+  "author": "SonOfMagic <qq1324318532@gmail.com>",
+  "license": "MIT",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
+  "devDependencies": {
+    "@types/babel__generator": "^7.6.4",
+    "@types/babel__traverse": "^7.18.3",
+    "@types/semver": "^7.3.13",
+    "defu": "^6.1.2",
+    "pkg-types": "^1.0.2",
+    "postcss": "^8.4.21",
+    "tailwindcss": "^3.3.1"
+  },
+  "dependencies": {
+    "@babel/generator": "^7.21.4",
+    "@babel/parser": "^7.21.4",
+    "@babel/traverse": "^7.21.4",
+    "@babel/types": "^7.21.4",
+    "semver": "^7.3.8"
+  },
   "scripts": {
     "dev": "cross-env NODE_ENV=development rollup -cw",
     "build": "cross-env NODE_ENV=production rollup -c",
     "dev:tsc": "tsc -p tsconfig.json --sourceMap",
     "build:tsc": "tsc -p tsconfig.json",
-    "test": "jest"
+    "test": "jest",
+    "postinstall": "echo postinstall",
+    "preinstall": "npx only-allow pnpm",
+    "patch": "ts-node src/cli.ts"
   }
 }

package/dist/index.es.js

@@ -1 +0,0 @@
-