@weapp-tailwindcss/cli 0.0.0-alpha.0 → 0.0.0-alpha.1

package/dist/index.cjs

@@ -3,19 +3,19 @@
 const commander = require('commander');
 const loadPostcssConfig = require('postcss-load-config');
 const path = require('node:path');
+const fs = require('fs-extra');
 const gulp = require('weapp-tailwindcss/gulp');
 const gulp$1 = require('gulp');
-const fs = require('fs-extra');
 const cosmiconfig = require('cosmiconfig');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 const loadPostcssConfig__default = /*#__PURE__*/_interopDefaultCompat(loadPostcssConfig);
 const path__default = /*#__PURE__*/_interopDefaultCompat(path);
-const gulp__default = /*#__PURE__*/_interopDefaultCompat(gulp$1);
 const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const gulp__default = /*#__PURE__*/_interopDefaultCompat(gulp$1);
 
-function isPlainObject(value) {
+function isPlainObject$2(value) {
   if (value === null || typeof value !== "object") {
     return false;
   }
@@ -33,7 +33,7 @@ function isPlainObject(value) {
 }
 
 function _defu(baseObject, defaults, namespace = ".", merger) {
-  if (!isPlainObject(defaults)) {
+  if (!isPlainObject$2(defaults)) {
     return _defu(baseObject, {}, namespace, merger);
   }
   const object = Object.assign({}, defaults);
@@ -50,7 +50,7 @@ function _defu(baseObject, defaults, namespace = ".", merger) {
     }
     if (Array.isArray(value) && Array.isArray(object[key])) {
       object[key] = [...value, ...object[key]];
-    } else if (isPlainObject(value) && isPlainObject(object[key])) {
+    } else if (isPlainObject$2(value) && isPlainObject$2(object[key])) {
       object[key] = _defu(
         value,
         object[key],
@@ -79,40 +79,21 @@ var AssetType = /* @__PURE__ */ ((AssetType2) => {
   return AssetType2;
 })(AssetType || {});
 
-const defaultJavascriptExtensions = ["js"];
-const defaultTypescriptExtensions = ["ts"];
-const defaultWxsExtensions = ["wxs"];
-const defaultNodeModulesDirs = ["**/node_modules/**", "**/miniprogram_npm/**", "**/project.config.json/**", "**/project.private.config.json/**", "**/package.json/**"];
-async function build(options) {
-  const {
-    root: cwd,
-    weappTailwindcssOptions,
-    outDir,
-    src: srcBase,
-    clean,
-    extensions,
-    exclude,
-    include
-  } = defu(options, {
-    outDir: "dist",
-    weappTailwindcssOptions: {},
-    clean: true,
-    src: "",
-    exclude: [...defaultNodeModulesDirs],
-    extensions: {
-      javascript: [...defaultJavascriptExtensions, ...defaultTypescriptExtensions, ...defaultWxsExtensions],
-      html: ["wxml"],
-      css: ["wxss", "less", "sass", "scss"],
-      json: ["json"]
+function getTasks(options) {
+  const { root: cwd, weappTailwindcssOptions, outDir, src: srcBase, extensions, exclude, include } = options;
+  const globsSet = /* @__PURE__ */ new Set();
+  const base = srcBase ? srcBase + "/" : "";
+  function globsSetAdd(...value) {
+    for (const v of value) {
+      if (Array.isArray(v)) {
+        for (const vv of v) {
+          globsSet.add(vv);
+        }
+      } else {
+        globsSet.add(v);
+      }
     }
-  });
-  if (clean) {
-    const { deleteAsync } = await import('del');
-    const patterns = [outDir + "/**"];
-    await deleteAsync(patterns, { cwd, ignore: defaultNodeModulesDirs });
   }
-  await fs.ensureDir(path__default.resolve(cwd, outDir));
-  const base = srcBase ? srcBase + "/" : "";
   function getGlobs(type) {
     const globs = [];
     if (typeof include === "function") {
@@ -130,8 +111,11 @@ async function build(options) {
   function getJsTasks() {
     const assetType = AssetType.JavaScript;
     const globs = getGlobs(assetType);
+    globsSetAdd(globs);
     return extensions[assetType].map((x) => {
-      return () => gulp__default.src([`${base}**/*.${x}`, ...globs], { cwd }).pipe(
+      const src = `${base}**/*.${x}`;
+      globsSetAdd(src);
+      return () => gulp__default.src([src, ...globs], { cwd }).pipe(
         transformJs({
           babelParserOptions: x === "ts" ? {
             plugins: ["typescript"]
@@ -147,8 +131,11 @@ async function build(options) {
   function getJsonTasks() {
     const assetType = AssetType.Json;
     const globs = getGlobs(assetType);
+    globsSetAdd(globs);
     return extensions[assetType].map((x) => {
-      return () => gulp__default.src([`${base}**/*.${x}`, ...globs], { cwd }).pipe(
+      const src = `${base}**/*.${x}`;
+      globsSetAdd(src);
+      return () => gulp__default.src([src, ...globs], { cwd }).pipe(
         gulp__default.dest(outDir, {
           cwd
         })
@@ -158,8 +145,11 @@ async function build(options) {
   function getCssTasks() {
     const assetType = AssetType.Css;
     const globs = getGlobs(assetType);
+    globsSetAdd(globs);
     return extensions[assetType].map((x) => {
-      return () => gulp__default.src([`${base}**/*.${x}`, ...globs], { cwd }).pipe(transformWxss()).pipe(
+      const src = `${base}**/*.${x}`;
+      globsSetAdd(src);
+      return () => gulp__default.src([src, ...globs], { cwd }).pipe(transformWxss()).pipe(
         gulp__default.dest(outDir, {
           cwd
         })
@@ -169,8 +159,11 @@ async function build(options) {
   function getHtmlTasks() {
     const assetType = AssetType.Html;
     const globs = getGlobs(assetType);
+    globsSetAdd(globs);
     return extensions[assetType].map((x) => {
-      return () => gulp__default.src([`${base}**/*.${x}`, ...globs], { cwd }).pipe(transformWxml()).pipe(
+      const src = `${base}**/*.${x}`;
+      globsSetAdd(src);
+      return () => gulp__default.src([src, ...globs], { cwd }).pipe(transformWxml()).pipe(
         gulp__default.dest(outDir, {
           cwd
         })
@@ -179,27 +172,450 @@ async function build(options) {
   }
   function copyOthers() {
     if (Array.isArray(include)) {
-      return gulp__default.src(
-        include.map((x) => {
-          return `${base}${x}`;
-        }),
-        { cwd }
-      ).pipe(
+      const globs = include.map((x) => {
+        return `${base}${x}`;
+      });
+      globsSetAdd(globs);
+      return gulp__default.src(globs, { cwd }).pipe(
         gulp__default.dest(outDir, {
           cwd
         })
       );
     }
   }
+  return {
+    getGlobs,
+    getJsTasks,
+    getJsonTasks,
+    getCssTasks,
+    getHtmlTasks,
+    copyOthers,
+    globsSet
+  };
+}
+
+const defaultJavascriptExtensions = ["js"];
+const defaultTypescriptExtensions = ["ts"];
+const defaultWxsExtensions = ["wxs"];
+const defaultNodeModulesDirs = [
+  "**/node_modules/**",
+  "**/miniprogram_npm/**",
+  "**/project.config.json/**",
+  "**/project.private.config.json/**",
+  "**/package.json/**",
+  "postcss.config.js",
+  "tailwind.config.js"
+];
+function createBuilder(options) {
+  const {
+    root: cwd,
+    weappTailwindcssOptions,
+    outDir,
+    src: srcBase,
+    clean,
+    extensions,
+    exclude,
+    include
+  } = defu(options, {
+    outDir: "dist",
+    weappTailwindcssOptions: {},
+    clean: true,
+    src: "",
+    exclude: [...defaultNodeModulesDirs],
+    extensions: {
+      javascript: [...defaultJavascriptExtensions, ...defaultTypescriptExtensions, ...defaultWxsExtensions],
+      html: ["wxml"],
+      css: ["wxss", "less", "sass", "scss"],
+      json: ["json"]
+    }
+  });
+  const { copyOthers, getCssTasks, getHtmlTasks, getJsTasks, getJsonTasks, globsSet } = getTasks({
+    root: cwd,
+    weappTailwindcssOptions,
+    outDir,
+    src: srcBase,
+    clean,
+    extensions,
+    exclude,
+    include
+  });
   const tasks = [...getJsTasks(), ...getJsonTasks(), ...getCssTasks(), ...getHtmlTasks(), copyOthers];
-  for (const task of tasks) {
-    const s = task();
-    if (s) {
-      await new Promise((resolve, reject) => s.on("finish", resolve).on("error", reject));
+  return {
+    async build() {
+      if (clean) {
+        const { deleteAsync } = await import('del');
+        const patterns = [outDir + "/**"];
+        await deleteAsync(patterns, { cwd, ignore: defaultNodeModulesDirs });
+      }
+      await fs.ensureDir(path__default.resolve(cwd, outDir));
+      for (const task of tasks) {
+        const s = task();
+        if (s) {
+          await new Promise((resolve, reject) => s.on("finish", resolve).on("error", reject));
+        }
+      }
+      return this;
+    },
+    async watch() {
+      await fs.ensureDir(path__default.resolve(cwd, outDir));
+      return this;
+    },
+    globsSet
+  };
+}
+function build(options) {
+  const builder = createBuilder(options);
+  return builder.build();
+}
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+/*!
+ * is-primitive <https://github.com/jonschlinkert/is-primitive>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isPrimitive$1 = function isPrimitive(val) {
+  if (typeof val === 'object') {
+    return val === null;
+  }
+  return typeof val !== 'function';
+};
+
+/*!
+ * isobject <https://github.com/jonschlinkert/isobject>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isobject = function isObject(val) {
+  return val != null && typeof val === 'object' && Array.isArray(val) === false;
+};
+
+/*!
+ * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isObject$2 = isobject;
+
+function isObjectObject(o) {
+  return isObject$2(o) === true
+    && Object.prototype.toString.call(o) === '[object Object]';
+}
+
+var isPlainObject$1 = function isPlainObject(o) {
+  var ctor,prot;
+
+  if (isObjectObject(o) === false) return false;
+
+  // If has modified constructor
+  ctor = o.constructor;
+  if (typeof ctor !== 'function') return false;
+
+  // If has modified prototype
+  prot = ctor.prototype;
+  if (isObjectObject(prot) === false) return false;
+
+  // If constructor does not have an Object-specific method
+  if (prot.hasOwnProperty('isPrototypeOf') === false) {
+    return false;
+  }
+
+  // Most likely a plain Object
+  return true;
+};
+
+/*!
+ * set-value <https://github.com/jonschlinkert/set-value>
+ *
+ * Copyright (c) Jon Schlinkert (https://github.com/jonschlinkert).
+ * Released under the MIT License.
+ */
+
+const { deleteProperty } = Reflect;
+const isPrimitive = isPrimitive$1;
+const isPlainObject = isPlainObject$1;
+
+const isObject$1 = value => {
+  return (typeof value === 'object' && value !== null) || typeof value === 'function';
+};
+
+const isUnsafeKey = key => {
+  return key === '__proto__' || key === 'constructor' || key === 'prototype';
+};
+
+const validateKey = key => {
+  if (!isPrimitive(key)) {
+    throw new TypeError('Object keys must be strings or symbols');
+  }
+
+  if (isUnsafeKey(key)) {
+    throw new Error(`Cannot set unsafe key: "${key}"`);
+  }
+};
+
+const toStringKey = input => {
+  return Array.isArray(input) ? input.flat().map(String).join(',') : input;
+};
+
+const createMemoKey = (input, options) => {
+  if (typeof input !== 'string' || !options) return input;
+  let key = input + ';';
+  if (options.arrays !== undefined) key += `arrays=${options.arrays};`;
+  if (options.separator !== undefined) key += `separator=${options.separator};`;
+  if (options.split !== undefined) key += `split=${options.split};`;
+  if (options.merge !== undefined) key += `merge=${options.merge};`;
+  if (options.preservePaths !== undefined) key += `preservePaths=${options.preservePaths};`;
+  return key;
+};
+
+const memoize = (input, options, fn) => {
+  const key = toStringKey(options ? createMemoKey(input, options) : input);
+  validateKey(key);
+
+  const value = setValue.cache.get(key) || fn();
+  setValue.cache.set(key, value);
+  return value;
+};
+
+const splitString = (input, options = {}) => {
+  const sep = options.separator || '.';
+  const preserve = sep === '/' ? false : options.preservePaths;
+
+  if (typeof input === 'string' && preserve !== false && /\//.test(input)) {
+    return [input];
+  }
+
+  const parts = [];
+  let part = '';
+
+  const push = part => {
+    let number;
+    if (part.trim() !== '' && Number.isInteger((number = Number(part)))) {
+      parts.push(number);
+    } else {
+      parts.push(part);
+    }
+  };
+
+  for (let i = 0; i < input.length; i++) {
+    const value = input[i];
+
+    if (value === '\\') {
+      part += input[++i];
+      continue;
+    }
+
+    if (value === sep) {
+      push(part);
+      part = '';
+      continue;
+    }
+
+    part += value;
+  }
+
+  if (part) {
+    push(part);
+  }
+
+  return parts;
+};
+
+const split$1 = (input, options) => {
+  if (options && typeof options.split === 'function') return options.split(input);
+  if (typeof input === 'symbol') return [input];
+  if (Array.isArray(input)) return input;
+  return memoize(input, options, () => splitString(input, options));
+};
+
+const assignProp = (obj, prop, value, options) => {
+  validateKey(prop);
+
+  // Delete property when "value" is undefined
+  if (value === undefined) {
+    deleteProperty(obj, prop);
+
+  } else if (options && options.merge) {
+    const merge = options.merge === 'function' ? options.merge : Object.assign;
+
+    // Only merge plain objects
+    if (merge && isPlainObject(obj[prop]) && isPlainObject(value)) {
+      obj[prop] = merge(obj[prop], value);
+    } else {
+      obj[prop] = value;
     }
+
+  } else {
+    obj[prop] = value;
   }
+
+  return obj;
+};
+
+const setValue = (target, path, value, options) => {
+  if (!path || !isObject$1(target)) return target;
+
+  const keys = split$1(path, options);
+  let obj = target;
+
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const next = keys[i + 1];
+
+    validateKey(key);
+
+    if (next === undefined) {
+      assignProp(obj, key, value, options);
+      break;
+    }
+
+    if (typeof next === 'number' && !Array.isArray(obj[key])) {
+      obj = obj[key] = [];
+      continue;
+    }
+
+    if (!isObject$1(obj[key])) {
+      obj[key] = {};
+    }
+
+    obj = obj[key];
+  }
+
+  return target;
+};
+
+setValue.split = split$1;
+setValue.cache = new Map();
+setValue.clear = () => {
+  setValue.cache = new Map();
+};
+
+var setValue_1 = setValue;
+
+const set = /*@__PURE__*/getDefaultExportFromCjs(setValue_1);
+
+/*!
+ * get-value <https://github.com/jonschlinkert/get-value>
+ *
+ * Copyright (c) 2014-2018, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+const isObject = isobject;
+
+var getValue = function(target, path, options) {
+  if (!isObject(options)) {
+    options = { default: options };
+  }
+
+  if (!isValidObject(target)) {
+    return typeof options.default !== 'undefined' ? options.default : target;
+  }
+
+  if (typeof path === 'number') {
+    path = String(path);
+  }
+
+  const isArray = Array.isArray(path);
+  const isString = typeof path === 'string';
+  const splitChar = options.separator || '.';
+  const joinChar = options.joinChar || (typeof splitChar === 'string' ? splitChar : '.');
+
+  if (!isString && !isArray) {
+    return target;
+  }
+
+  if (isString && path in target) {
+    return isValid(path, target, options) ? target[path] : options.default;
+  }
+
+  let segs = isArray ? path : split(path, splitChar, options);
+  let len = segs.length;
+  let idx = 0;
+
+  do {
+    let prop = segs[idx];
+    if (typeof prop === 'number') {
+      prop = String(prop);
+    }
+
+    while (prop && prop.slice(-1) === '\\') {
+      prop = join([prop.slice(0, -1), segs[++idx] || ''], joinChar, options);
+    }
+
+    if (prop in target) {
+      if (!isValid(prop, target, options)) {
+        return options.default;
+      }
+
+      target = target[prop];
+    } else {
+      let hasProp = false;
+      let n = idx + 1;
+
+      while (n < len) {
+        prop = join([prop, segs[n++]], joinChar, options);
+
+        if ((hasProp = prop in target)) {
+          if (!isValid(prop, target, options)) {
+            return options.default;
+          }
+
+          target = target[prop];
+          idx = n - 1;
+          break;
+        }
+      }
+
+      if (!hasProp) {
+        return options.default;
+      }
+    }
+  } while (++idx < len && isValidObject(target));
+
+  if (idx === len) {
+    return target;
+  }
+
+  return options.default;
+};
+
+function join(segs, joinChar, options) {
+  if (typeof options.join === 'function') {
+    return options.join(segs);
+  }
+  return segs[0] + joinChar + segs[1];
+}
+
+function split(path, splitChar, options) {
+  if (typeof options.split === 'function') {
+    return options.split(path);
+  }
+  return path.split(splitChar);
+}
+
+function isValid(key, target, options) {
+  if (typeof options.isValid === 'function') {
+    return options.isValid(key, target);
+  }
+  return true;
 }
 
+function isValidObject(val) {
+  return isObject(val) || Array.isArray(val) || typeof val === 'function';
+}
+
+const get = /*@__PURE__*/getDefaultExportFromCjs(getValue);
+
 function createConfigLoader(root) {
   const explorer = cosmiconfig.cosmiconfigSync("weapp-tw");
   function search(searchFrom = root) {
@@ -234,10 +650,10 @@ function updateProjectConfig(options) {
   if (fs__default.existsSync(projectConfigPath)) {
     try {
       const projectConfig = fs__default.readJSONSync(projectConfigPath);
-      projectConfig.miniprogramRoot = "dist/";
-      projectConfig.srcMiniprogramRoot = "dist/";
-      projectConfig.setting.packNpmManually = true;
-      if (Array.isArray(projectConfig.setting.packNpmRelationList)) {
+      set(projectConfig, "miniprogramRoot", "dist/");
+      set(projectConfig, "srcMiniprogramRoot", "dist/");
+      set(projectConfig, "setting.packNpmManually", true);
+      if (Array.isArray(get(projectConfig, "setting.packNpmRelationList"))) {
         const x = projectConfig.setting.packNpmRelationList.find((x2) => x2.packageJsonPath === "./package.json" && x2.miniprogramNpmDistDir === "./dist");
         if (!x) {
           projectConfig.setting.packNpmRelationList.push({
@@ -246,12 +662,12 @@ function updateProjectConfig(options) {
           });
         }
       } else {
-        projectConfig.setting.packNpmRelationList = [
+        set(projectConfig, "setting.packNpmRelationList", [
           {
             packageJsonPath: "./package.json",
             miniprogramNpmDistDir: "./dist"
           }
-        ];
+        ]);
       }
       fs__default.outputJSONSync(dest ?? projectConfigPath, projectConfig, {
         spaces: 2
@@ -264,6 +680,22 @@ function updateProjectConfig(options) {
     console.warn(`\u2728 \u6CA1\u6709\u627E\u5230 ${projectConfigFilename} \u6587\u4EF6!`);
   }
 }
+function updatePackageJson(options) {
+  const { root, dest } = options;
+  const packageJsonFilename = "package.json";
+  const packageJsonPath = path__default.resolve(root, packageJsonFilename);
+  if (fs__default.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = fs__default.readJSONSync(packageJsonPath);
+      set(packageJson, "scripts.dev", "weapp-tw dev");
+      set(packageJson, "scripts.build", "weapp-tw build");
+      fs__default.outputJSONSync(dest ?? packageJsonPath, packageJson, {
+        spaces: 2
+      });
+    } catch {
+    }
+  }
+}
 function initConfig(options) {
   const { lang, root } = defu(options, { lang: "js", root: process.cwd() });
   const configFilename = `weapp-tw.config.${lang ?? "js"}`;
@@ -289,6 +721,7 @@ module.exports = {}
   }
   console.log(`\u2728 ${configFilename} \u914D\u7F6E\u6587\u4EF6\uFF0C\u521D\u59CB\u5316\u6210\u529F!`);
   updateProjectConfig({ root });
+  updatePackageJson({ root });
   return configPath;
 }
 
@@ -320,10 +753,8 @@ function createCli() {
   return program;
 }
 
-function createWatcher(options) {
-}
-
+exports.build = build;
+exports.createBuilder = createBuilder;
 exports.createCli = createCli;
 exports.createConfigLoader = createConfigLoader;
-exports.createWatcher = createWatcher;
 exports.defineConfig = defineConfig;