tailwindcss-patch 1.0.4 → 1.1.0-rc.1

package/dist/cli.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var patcher = require('./patcher-90d636ff.js');
+var patcher = require('./patcher-8dfb86e3.js');
 require('path');
 require('fs');
 require('semver');
@@ -10,5 +10,6 @@ require('@babel/parser');
 require('@babel/traverse');
 require('resolve');
 
-const patch = patcher.createPatch();
+const opt = patcher.getPatchOptions();
+const patch = patcher.createPatch(opt);
 patch();

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-8dfb86e3.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,14 +52,125 @@ 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$1(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$1(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$1(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);
+        }
+    }
+}
+
+function getCacheOptions(options) {
+    let cache;
+    switch (typeof options) {
+        case 'undefined': {
+            cache = {
+                enable: false
+            };
+            break;
+        }
+        case 'boolean': {
+            cache = {
+                enable: options
+            };
+            break;
+        }
+        case 'object': {
+            cache = Object.assign(Object.assign({}, options), { enable: true });
+            break;
+        }
+    }
+    return cache;
+}
+class TailwindcssPatcher {
+    constructor(options = {}) {
+        this.rawOptions = options;
+        this.cacheOptions = getCacheOptions(options.cache);
+        this.patchOptions = patcher.getPatchOptions(options.patch);
+        this.patch = patcher.createPatch(this.patchOptions);
+    }
+    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;
+exports.getPatchOptions = patcher.getPatchOptions;
 exports.inspectPostcssPlugin = patcher.inspectPostcssPlugin;
 exports.inspectProcessTailwindFeaturesReturnContext = patcher.inspectProcessTailwindFeaturesReturnContext;
 exports.internalPatch = patcher.internalPatch;
 exports.monkeyPatchForExposingContext = patcher.monkeyPatchForExposingContext;
 exports.requireResolve = patcher.requireResolve;
+exports.TailwindcssPatcher = TailwindcssPatcher;
+exports.getCacheOptions = getCacheOptions;
 exports.getClassCacheSet = getClassCacheSet;
 exports.getClassCaches = getClassCaches;
 exports.getContexts = getContexts;

package/dist/{patcher-90d636ff.js → patcher-8dfb86e3.js}

@@ -240,11 +240,15 @@ function getInstalledPkgJsonPath(options = {}) {
         }
     }
 }
-function createPatch(options = {}) {
-    const opt = defu(options, defaultOptions);
+function getPatchOptions(options = {}) {
+    return defu(options, {
+        basedir: process.cwd()
+    }, defaultOptions);
+}
+function createPatch(opt) {
     return () => {
         try {
-            const pkgJsonPath = getInstalledPkgJsonPath(options);
+            const pkgJsonPath = getInstalledPkgJsonPath(opt);
             return internalPatch(pkgJsonPath, opt);
         }
         catch (error) {
@@ -296,6 +300,7 @@ function internalPatch(pkgJsonPath, options) {
 exports.createPatch = createPatch;
 exports.ensureFileContent = ensureFileContent;
 exports.getInstalledPkgJsonPath = getInstalledPkgJsonPath;
+exports.getPatchOptions = getPatchOptions;
 exports.inspectPostcssPlugin = inspectPostcssPlugin;
 exports.inspectProcessTailwindFeaturesReturnContext = inspectProcessTailwindFeaturesReturnContext;
 exports.internalPatch = internalPatch;

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,18 @@
+import type { CacheOptions, PatchOptions, InternalCacheOptions, InternalPatchOptions } from './type';
+export interface TailwindcssPatcherOptions {
+    cache?: CacheOptions;
+    patch?: PatchOptions;
+}
+export declare function getCacheOptions(options?: CacheOptions): InternalCacheOptions;
+export declare class TailwindcssPatcher {
+    rawOptions: TailwindcssPatcherOptions;
+    cacheOptions: InternalCacheOptions;
+    patchOptions: InternalPatchOptions;
+    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/patcher.d.ts

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

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.1",
   "description": "patch tailwindcss for exposing context",
   "main": "dist/index.js",
   "types": "dist/types/index.d.ts",