tailwindcss-patch 1.0.4 → 1.1.0-rc.0

package/dist/cli.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var patcher = require('./patcher-90d636ff.js');
+var patcher = require('./patcher-75f59039.js');
 require('path');
 require('fs');
 require('semver');

package/dist/index.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var path = require('path');
 var fs = require('fs');
-var patcher = require('./patcher-90d636ff.js');
+var patcher = require('./patcher-75f59039.js');
 require('semver');
 require('@babel/types');
 require('@babel/generator');
@@ -35,12 +35,12 @@ function getContexts(basedir) {
     }
     return [];
 }
-function getClassCaches() {
-    const contexts = getContexts();
+function getClassCaches(basedir) {
+    const contexts = getContexts(basedir);
     return contexts.map((x) => x.classCache);
 }
-function getClassCacheSet() {
-    const classCaches = getClassCaches();
+function getClassCacheSet(basedir) {
+    const classCaches = getClassCaches(basedir);
     const classSet = new Set();
     for (let i = 0; i < classCaches.length; i++) {
         const classCacheMap = classCaches[i];
@@ -52,6 +52,111 @@ function getClassCacheSet() {
     return classSet;
 }
 
+const pkgName = 'tailwindcss-patch';
+
+function log(message, ...optionalParams) {
+    return console.log(`[${pkgName}]:` + message, ...optionalParams);
+}
+
+function mkCacheDirectory(cacheDirectory) {
+    const exists = fs__default["default"].existsSync(cacheDirectory);
+    if (!exists) {
+        fs__default["default"].mkdirSync(cacheDirectory, {
+            recursive: true
+        });
+    }
+    return cacheDirectory;
+}
+function getCacheOptions(options = {}) {
+    var _a, _b, _c;
+    const cwd = (_a = options.cwd) !== null && _a !== void 0 ? _a : process.cwd();
+    const dir = (_b = options.dir) !== null && _b !== void 0 ? _b : path__default["default"].resolve(cwd, 'node_modules/.cache', pkgName);
+    const file = (_c = options.file) !== null && _c !== void 0 ? _c : 'index.json';
+    const filename = path__default["default"].resolve(dir, file);
+    return {
+        cwd,
+        dir,
+        file,
+        filename
+    };
+}
+function writeCache(data, options = {}) {
+    try {
+        const { dir, filename } = getCacheOptions(options);
+        mkCacheDirectory(dir);
+        fs__default["default"].writeFileSync(filename, JSON.stringify(Array.from(data), null, 2), 'utf-8');
+        return filename;
+    }
+    catch (error) {
+        log('write cache file fail!');
+    }
+}
+function readCache(options = {}) {
+    const { filename } = getCacheOptions(options);
+    try {
+        if (fs__default["default"].existsSync(filename)) {
+            const data = fs__default["default"].readFileSync(filename, 'utf-8');
+            return new Set(JSON.parse(data));
+        }
+    }
+    catch (error) {
+        log('parse cache content fail! path:' + filename);
+        try {
+            fs__default["default"].unlinkSync(filename);
+        }
+        catch (error) {
+            log('delete cache file fail! path:' + filename);
+        }
+    }
+}
+
+class TailwindcssPatcher {
+    constructor(options = {}) {
+        this.rawOptions = options;
+        let cache;
+        switch (typeof options.cache) {
+            case 'undefined': {
+                cache = {
+                    enable: false
+                };
+                break;
+            }
+            case 'boolean': {
+                cache = {
+                    enable: options.cache
+                };
+                break;
+            }
+            case 'object': {
+                cache = Object.assign(Object.assign({}, options.cache), { enable: true });
+                break;
+            }
+        }
+        this.cacheOptions = cache;
+        this.patchOptions = options.patch;
+        this.patch = patcher.createPatch(options.patch);
+    }
+    getPkgEntry(basedir) {
+        return getTailwindcssEntry(basedir);
+    }
+    setCache(set) {
+        if (this.cacheOptions.enable) {
+            return writeCache(set, this.cacheOptions);
+        }
+    }
+    getCache() {
+        return readCache(this.cacheOptions);
+    }
+    getClassSet(basedir) {
+        const set = getClassCacheSet(basedir);
+        set.size && this.setCache(set);
+        return set;
+    }
+    getContexts(basedir) {
+        return getContexts(basedir);
+    }
+}
+
 exports.createPatch = patcher.createPatch;
 exports.ensureFileContent = patcher.ensureFileContent;
 exports.getInstalledPkgJsonPath = patcher.getInstalledPkgJsonPath;
@@ -60,6 +165,7 @@ exports.inspectProcessTailwindFeaturesReturnContext = patcher.inspectProcessTail
 exports.internalPatch = patcher.internalPatch;
 exports.monkeyPatchForExposingContext = patcher.monkeyPatchForExposingContext;
 exports.requireResolve = patcher.requireResolve;
+exports.TailwindcssPatcher = TailwindcssPatcher;
 exports.getClassCacheSet = getClassCacheSet;
 exports.getClassCaches = getClassCaches;
 exports.getContexts = getContexts;

package/dist/{patcher-90d636ff.js → patcher-75f59039.js}

@@ -241,10 +241,12 @@ function getInstalledPkgJsonPath(options = {}) {
     }
 }
 function createPatch(options = {}) {
-    const opt = defu(options, defaultOptions);
+    const opt = defu(options, {
+        basedir: process.cwd()
+    }, defaultOptions);
     return () => {
         try {
-            const pkgJsonPath = getInstalledPkgJsonPath(options);
+            const pkgJsonPath = getInstalledPkgJsonPath(opt);
             return internalPatch(pkgJsonPath, opt);
         }
         catch (error) {

package/dist/types/cache.d.ts

@@ -0,0 +1,7 @@
+import type { CacheOptions } from './type';
+export declare function mkCacheDirectory(cacheDirectory: string): string;
+export declare function getCacheOptions(options?: CacheOptions): Required<CacheOptions> & {
+    filename: string;
+};
+export declare function writeCache(data: Set<string>, options?: CacheOptions): string | undefined;
+export declare function readCache(options?: CacheOptions): Set<string> | undefined;

package/dist/types/class.d.ts

@@ -0,0 +1,17 @@
+import type { InternalCacheOptions, PatchOptions } from './type';
+export interface TailwindcssPatcherOptions {
+    cache?: InternalCacheOptions;
+    patch?: PatchOptions;
+}
+export declare class TailwindcssPatcher {
+    rawOptions: TailwindcssPatcherOptions;
+    cacheOptions: InternalCacheOptions;
+    patchOptions?: PatchOptions;
+    patch: () => void;
+    constructor(options?: TailwindcssPatcherOptions);
+    getPkgEntry(basedir?: string): string;
+    setCache(set: Set<string>): string | undefined;
+    getCache(): Set<string> | undefined;
+    getClassSet(basedir?: string): Set<string>;
+    getContexts(basedir?: string): any[];
+}

package/dist/types/constants.d.ts

@@ -0,0 +1 @@
+export declare const pkgName = "tailwindcss-patch";

package/dist/types/exposeContext.d.ts

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

package/dist/types/index.d.ts

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

package/dist/types/logger.d.ts

@@ -0,0 +1 @@
+export declare function log(message?: any, ...optionalParams: any[]): void;

package/dist/types/type.d.ts

@@ -1,3 +1,11 @@
+export interface CacheOptions {
+    dir?: string;
+    cwd?: string;
+    file?: string;
+}
+export type InternalCacheOptions = CacheOptions & {
+    enable?: boolean;
+};
 export interface PatchOptions {
     overwrite?: boolean;
     paths?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tailwindcss-patch",
-  "version": "1.0.4",
+  "version": "1.1.0-rc.0",
   "description": "patch tailwindcss for exposing context",
   "main": "dist/index.js",
   "types": "dist/types/index.d.ts",