@unocss/config 0.1.0 → 0.1.1

package/dist/index.js

@@ -22,6 +22,12 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   __markAsModule(target);
   for (var name in all)
@@ -38,187 +44,339 @@ var __reExport = (target, module2, desc) => {
 var __toModule = (module2) => {
   return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
 };
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateWrapper = (obj, member, setter, getter) => {
-  return {
-    set _(value) {
-      __privateSet(obj, member, value, setter);
-    },
-    get _() {
-      return __privateGet(obj, member, getter);
-    }
-  };
-};
 
-// src/index.ts
-__export(exports, {
-  loadConfig: () => loadConfig,
-  readConfig: () => readConfig
+// ../../node_modules/.pnpm/tsup@5.5.0_typescript@4.4.4/node_modules/tsup/assets/cjs_shims.js
+var importMetaUrlShim;
+var init_cjs_shims = __esm({
+  "../../node_modules/.pnpm/tsup@5.5.0_typescript@4.4.4/node_modules/tsup/assets/cjs_shims.js"() {
+    importMetaUrlShim = typeof document === "undefined" ? new (require("url")).URL("file:" + __filename).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
+  }
 });
-var import_fs = __toModule(require("fs"));
-
-// ../../node_modules/.pnpm/find-up@6.2.0/node_modules/find-up/index.js
-var import_node_path2 = __toModule(require("node:path"));
-
-// ../../node_modules/.pnpm/locate-path@7.0.0/node_modules/locate-path/index.js
-var import_node_process = __toModule(require("node:process"));
-var import_node_path = __toModule(require("node:path"));
-var import_node_fs = __toModule(require("node:fs"));
 
-// ../../node_modules/.pnpm/yocto-queue@1.0.0/node_modules/yocto-queue/index.js
-var Node = class {
-  constructor(value) {
-    __publicField(this, "value");
-    __publicField(this, "next");
-    this.value = value;
-  }
-};
-var _head, _tail, _size;
-var Queue = class {
-  constructor() {
-    __privateAdd(this, _head, void 0);
-    __privateAdd(this, _tail, void 0);
-    __privateAdd(this, _size, void 0);
-    this.clear();
-  }
-  enqueue(value) {
-    const node = new Node(value);
-    if (__privateGet(this, _head)) {
-      __privateGet(this, _tail).next = node;
-      __privateSet(this, _tail, node);
-    } else {
-      __privateSet(this, _head, node);
-      __privateSet(this, _tail, node);
-    }
-    __privateWrapper(this, _size)._++;
-  }
-  dequeue() {
-    const current = __privateGet(this, _head);
-    if (!current) {
-      return;
-    }
-    __privateSet(this, _head, __privateGet(this, _head).next);
-    __privateWrapper(this, _size)._--;
-    return current.value;
-  }
-  clear() {
-    __privateSet(this, _head, void 0);
-    __privateSet(this, _tail, void 0);
-    __privateSet(this, _size, 0);
-  }
-  get size() {
-    return __privateGet(this, _size);
+// ../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js
+var require_yocto_queue = __commonJS({
+  "../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js"(exports, module2) {
+    init_cjs_shims();
+    var Node = class {
+      constructor(value) {
+        this.value = value;
+        this.next = void 0;
+      }
+    };
+    var Queue = class {
+      constructor() {
+        this.clear();
+      }
+      enqueue(value) {
+        const node = new Node(value);
+        if (this._head) {
+          this._tail.next = node;
+          this._tail = node;
+        } else {
+          this._head = node;
+          this._tail = node;
+        }
+        this._size++;
+      }
+      dequeue() {
+        const current = this._head;
+        if (!current) {
+          return;
+        }
+        this._head = this._head.next;
+        this._size--;
+        return current.value;
+      }
+      clear() {
+        this._head = void 0;
+        this._tail = void 0;
+        this._size = 0;
+      }
+      get size() {
+        return this._size;
+      }
+      *[Symbol.iterator]() {
+        let current = this._head;
+        while (current) {
+          yield current.value;
+          current = current.next;
+        }
+      }
+    };
+    module2.exports = Queue;
   }
-  *[Symbol.iterator]() {
-    let current = __privateGet(this, _head);
-    while (current) {
-      yield current.value;
-      current = current.next;
-    }
+});
+
+// ../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js
+var require_p_limit = __commonJS({
+  "../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js"(exports, module2) {
+    init_cjs_shims();
+    "use strict";
+    var Queue = require_yocto_queue();
+    var pLimit = (concurrency) => {
+      if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+        throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+      }
+      const queue = new Queue();
+      let activeCount = 0;
+      const next = () => {
+        activeCount--;
+        if (queue.size > 0) {
+          queue.dequeue()();
+        }
+      };
+      const run = async (fn, resolve, ...args) => {
+        activeCount++;
+        const result = (async () => fn(...args))();
+        resolve(result);
+        try {
+          await result;
+        } catch {
+        }
+        next();
+      };
+      const enqueue = (fn, resolve, ...args) => {
+        queue.enqueue(run.bind(null, fn, resolve, ...args));
+        (async () => {
+          await Promise.resolve();
+          if (activeCount < concurrency && queue.size > 0) {
+            queue.dequeue()();
+          }
+        })();
+      };
+      const generator = (fn, ...args) => new Promise((resolve) => {
+        enqueue(fn, resolve, ...args);
+      });
+      Object.defineProperties(generator, {
+        activeCount: {
+          get: () => activeCount
+        },
+        pendingCount: {
+          get: () => queue.size
+        },
+        clearQueue: {
+          value: () => {
+            queue.clear();
+          }
+        }
+      });
+      return generator;
+    };
+    module2.exports = pLimit;
   }
-};
-_head = new WeakMap();
-_tail = new WeakMap();
-_size = new WeakMap();
+});
 
-// ../../node_modules/.pnpm/locate-path@7.0.0/node_modules/locate-path/index.js
-var typeMappings = {
-  directory: "isDirectory",
-  file: "isFile"
-};
-function checkType(type) {
-  if (type in typeMappings) {
-    return;
+// ../../node_modules/.pnpm/p-locate@5.0.0/node_modules/p-locate/index.js
+var require_p_locate = __commonJS({
+  "../../node_modules/.pnpm/p-locate@5.0.0/node_modules/p-locate/index.js"(exports, module2) {
+    init_cjs_shims();
+    "use strict";
+    var pLimit = require_p_limit();
+    var EndError = class extends Error {
+      constructor(value) {
+        super();
+        this.value = value;
+      }
+    };
+    var testElement = async (element, tester) => tester(await element);
+    var finder = async (element) => {
+      const values = await Promise.all(element);
+      if (values[1] === true) {
+        throw new EndError(values[0]);
+      }
+      return false;
+    };
+    var pLocate = async (iterable, tester, options) => {
+      options = __spreadValues({
+        concurrency: Infinity,
+        preserveOrder: true
+      }, options);
+      const limit = pLimit(options.concurrency);
+      const items = [...iterable].map((element) => [element, limit(testElement, element, tester)]);
+      const checkLimit = pLimit(options.preserveOrder ? 1 : Infinity);
+      try {
+        await Promise.all(items.map((element) => checkLimit(finder, element)));
+      } catch (error) {
+        if (error instanceof EndError) {
+          return error.value;
+        }
+        throw error;
+      }
+    };
+    module2.exports = pLocate;
   }
-  throw new Error(`Invalid type specified: ${type}`);
-}
-var matchType = (type, stat) => type === void 0 || stat[typeMappings[type]]();
-function locatePathSync(paths, {
-  cwd = import_node_process.default.cwd(),
-  type = "file",
-  allowSymlinks = true
-} = {}) {
-  checkType(type);
-  const statFunction = allowSymlinks ? import_node_fs.default.statSync : import_node_fs.default.lstatSync;
-  for (const path_ of paths) {
-    try {
-      const stat = statFunction(import_node_path.default.resolve(cwd, path_));
-      if (matchType(type, stat)) {
-        return path_;
+});
+
+// ../../node_modules/.pnpm/locate-path@6.0.0/node_modules/locate-path/index.js
+var require_locate_path = __commonJS({
+  "../../node_modules/.pnpm/locate-path@6.0.0/node_modules/locate-path/index.js"(exports, module2) {
+    init_cjs_shims();
+    "use strict";
+    var path = require("path");
+    var fs2 = require("fs");
+    var { promisify } = require("util");
+    var pLocate = require_p_locate();
+    var fsStat = promisify(fs2.stat);
+    var fsLStat = promisify(fs2.lstat);
+    var typeMappings = {
+      directory: "isDirectory",
+      file: "isFile"
+    };
+    function checkType({ type }) {
+      if (type in typeMappings) {
+        return;
       }
-    } catch {
+      throw new Error(`Invalid type specified: ${type}`);
     }
+    var matchType = (type, stat) => type === void 0 || stat[typeMappings[type]]();
+    module2.exports = async (paths, options) => {
+      options = __spreadValues({
+        cwd: process.cwd(),
+        type: "file",
+        allowSymlinks: true
+      }, options);
+      checkType(options);
+      const statFn = options.allowSymlinks ? fsStat : fsLStat;
+      return pLocate(paths, async (path_) => {
+        try {
+          const stat = await statFn(path.resolve(options.cwd, path_));
+          return matchType(options.type, stat);
+        } catch {
+          return false;
+        }
+      }, options);
+    };
+    module2.exports.sync = (paths, options) => {
+      options = __spreadValues({
+        cwd: process.cwd(),
+        allowSymlinks: true,
+        type: "file"
+      }, options);
+      checkType(options);
+      const statFn = options.allowSymlinks ? fs2.statSync : fs2.lstatSync;
+      for (const path_ of paths) {
+        try {
+          const stat = statFn(path.resolve(options.cwd, path_));
+          if (matchType(options.type, stat)) {
+            return path_;
+          }
+        } catch {
+        }
+      }
+    };
   }
-}
+});
 
-// ../../node_modules/.pnpm/path-exists@5.0.0/node_modules/path-exists/index.js
-var import_node_fs2 = __toModule(require("node:fs"));
+// ../../node_modules/.pnpm/path-exists@4.0.0/node_modules/path-exists/index.js
+var require_path_exists = __commonJS({
+  "../../node_modules/.pnpm/path-exists@4.0.0/node_modules/path-exists/index.js"(exports, module2) {
+    init_cjs_shims();
+    "use strict";
+    var fs2 = require("fs");
+    var { promisify } = require("util");
+    var pAccess = promisify(fs2.access);
+    module2.exports = async (path) => {
+      try {
+        await pAccess(path);
+        return true;
+      } catch (_) {
+        return false;
+      }
+    };
+    module2.exports.sync = (path) => {
+      try {
+        fs2.accessSync(path);
+        return true;
+      } catch (_) {
+        return false;
+      }
+    };
+  }
+});
 
-// ../../node_modules/.pnpm/find-up@6.2.0/node_modules/find-up/index.js
-var findUpStop = Symbol("findUpStop");
-function findUpMultipleSync(name, options = {}) {
-  let directory = import_node_path2.default.resolve(options.cwd || "");
-  const { root } = import_node_path2.default.parse(directory);
-  const stopAt = options.stopAt || root;
-  const limit = options.limit || Number.POSITIVE_INFINITY;
-  const paths = [name].flat();
-  const runMatcher = (locateOptions) => {
-    if (typeof name !== "function") {
-      return locatePathSync(paths, locateOptions);
-    }
-    const foundPath = name(locateOptions.cwd);
-    if (typeof foundPath === "string") {
-      return locatePathSync([foundPath], locateOptions);
-    }
-    return foundPath;
-  };
-  const matches = [];
-  while (true) {
-    const foundPath = runMatcher(__spreadProps(__spreadValues({}, options), { cwd: directory }));
-    if (foundPath === findUpStop) {
-      break;
-    }
-    if (foundPath) {
-      matches.push(import_node_path2.default.resolve(directory, foundPath));
-    }
-    if (directory === stopAt || matches.length >= limit) {
-      break;
-    }
-    directory = import_node_path2.default.dirname(directory);
+// ../../node_modules/.pnpm/find-up@5.0.0/node_modules/find-up/index.js
+var require_find_up = __commonJS({
+  "../../node_modules/.pnpm/find-up@5.0.0/node_modules/find-up/index.js"(exports, module2) {
+    init_cjs_shims();
+    "use strict";
+    var path = require("path");
+    var locatePath = require_locate_path();
+    var pathExists = require_path_exists();
+    var stop = Symbol("findUp.stop");
+    module2.exports = async (name, options = {}) => {
+      let directory = path.resolve(options.cwd || "");
+      const { root } = path.parse(directory);
+      const paths = [].concat(name);
+      const runMatcher = async (locateOptions) => {
+        if (typeof name !== "function") {
+          return locatePath(paths, locateOptions);
+        }
+        const foundPath = await name(locateOptions.cwd);
+        if (typeof foundPath === "string") {
+          return locatePath([foundPath], locateOptions);
+        }
+        return foundPath;
+      };
+      while (true) {
+        const foundPath = await runMatcher(__spreadProps(__spreadValues({}, options), { cwd: directory }));
+        if (foundPath === stop) {
+          return;
+        }
+        if (foundPath) {
+          return path.resolve(directory, foundPath);
+        }
+        if (directory === root) {
+          return;
+        }
+        directory = path.dirname(directory);
+      }
+    };
+    module2.exports.sync = (name, options = {}) => {
+      let directory = path.resolve(options.cwd || "");
+      const { root } = path.parse(directory);
+      const paths = [].concat(name);
+      const runMatcher = (locateOptions) => {
+        if (typeof name !== "function") {
+          return locatePath.sync(paths, locateOptions);
+        }
+        const foundPath = name(locateOptions.cwd);
+        if (typeof foundPath === "string") {
+          return locatePath.sync([foundPath], locateOptions);
+        }
+        return foundPath;
+      };
+      while (true) {
+        const foundPath = runMatcher(__spreadProps(__spreadValues({}, options), { cwd: directory }));
+        if (foundPath === stop) {
+          return;
+        }
+        if (foundPath) {
+          return path.resolve(directory, foundPath);
+        }
+        if (directory === root) {
+          return;
+        }
+        directory = path.dirname(directory);
+      }
+    };
+    module2.exports.exists = pathExists;
+    module2.exports.sync.exists = pathExists.sync;
+    module2.exports.stop = stop;
   }
-  return matches;
-}
-function findUpSync(name, options = {}) {
-  const matches = findUpMultipleSync(name, __spreadProps(__spreadValues({}, options), { limit: 1 }));
-  return matches[0];
-}
+});
 
 // src/index.ts
+__export(exports, {
+  loadConfig: () => loadConfig,
+  readConfig: () => readConfig
+});
+init_cjs_shims();
+var import_fs = __toModule(require("fs"));
+var import_find_up = __toModule(require_find_up());
 var import_sucrase = __toModule(require("sucrase"));
-function isDir(path3) {
+function isDir(path) {
   try {
-    const stat = import_fs.default.lstatSync(path3);
+    const stat = import_fs.default.lstatSync(path);
     return stat.isDirectory();
   } catch (e) {
     return false;
@@ -230,7 +388,7 @@ function loadConfig(dirOrPath = process.cwd()) {
       config: dirOrPath
     };
   }
-  const filepath = isDir(dirOrPath) ? findUpSync([
+  const filepath = isDir(dirOrPath) ? import_find_up.default.sync([
     "unocss.config.js",
     "unocss.config.cjs",
     "unocss.config.mjs",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@unocss/config",
-	"version": "0.1.0",
+	"version": "0.1.1",
 	"description": "Config loader for UnoCSS",
 	"keywords": [],
 	"homepage": "https://github.com/antfu/unocss#readme",
@@ -23,12 +23,15 @@
 	"files": [
 		"dist"
 	],
+	"engines": {
+		"node": ">=14"
+	},
 	"dependencies": {
-		"@unocss/core": "0.1.0",
+		"@unocss/core": "0.1.1",
 		"sucrase": "^3.20.3"
 	},
 	"devDependencies": {
-		"find-up": "^6.2.0"
+		"find-up": "^5"
 	},
 	"scripts": {
 		"build": "tsup",