@unocss/config 0.1.0-beta.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Anthony Fu <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { UserConfig } from 'unocss';
+
+interface ConfigResult<U> {
+    filepath?: string;
+    config?: U;
+}
+declare function loadConfig<U extends UserConfig>(dirOrPath?: string | U): ConfigResult<U>;
+declare function readConfig<U>(filepath: string): ConfigResult<U>;
+
+export { ConfigResult, loadConfig, readConfig };

package/dist/index.js

@@ -0,0 +1,258 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+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
+});
+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);
+  }
+  *[Symbol.iterator]() {
+    let current = __privateGet(this, _head);
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+};
+_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;
+  }
+  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_;
+      }
+    } 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/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);
+  }
+  return matches;
+}
+function findUpSync(name, options = {}) {
+  const matches = findUpMultipleSync(name, __spreadProps(__spreadValues({}, options), { limit: 1 }));
+  return matches[0];
+}
+
+// src/index.ts
+var import_sucrase = __toModule(require("sucrase"));
+function isDir(path3) {
+  try {
+    const stat = import_fs.default.lstatSync(path3);
+    return stat.isDirectory();
+  } catch (e) {
+    return false;
+  }
+}
+function loadConfig(dirOrPath = process.cwd()) {
+  if (typeof dirOrPath !== "string") {
+    return {
+      config: dirOrPath
+    };
+  }
+  const filepath = isDir(dirOrPath) ? findUpSync([
+    "unocss.config.js",
+    "unocss.config.cjs",
+    "unocss.config.mjs",
+    "unocss.config.ts",
+    "unocss.config.mts",
+    "unocss.config.cts"
+  ], { cwd: dirOrPath }) : dirOrPath;
+  if (!filepath || !import_fs.default.existsSync(filepath))
+    return {};
+  return readConfig(filepath);
+}
+function readConfig(filepath) {
+  const content = import_fs.default.readFileSync(filepath, "utf-8");
+  const transformed = (0, import_sucrase.transform)(content, { transforms: ["typescript", "imports"] }).code;
+  const result = new Function("require", `let exports = {};${transformed}; return exports.default;`)(require);
+  return {
+    filepath,
+    config: result
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadConfig,
+  readConfig
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+	"name": "@unocss/config",
+	"version": "0.1.0-beta.2",
+	"description": "Config loader for UnoCSS",
+	"keywords": [],
+	"homepage": "https://github.com/antfu/unocss#readme",
+	"bugs": {
+		"url": "https://github.com/antfu/unocss/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/antfu/unocss.git"
+	},
+	"funding": "https://github.com/sponsors/antfu",
+	"license": "MIT",
+	"author": "Anthony Fu <anthonyfu117@hotmail.com>",
+	"sideEffects": false,
+	"exports": {
+		".": "./dist/index.js"
+	},
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"files": [
+		"dist"
+	],
+	"dependencies": {
+		"@unocss/core": "0.1.0-beta.2",
+		"sucrase": "^3.20.3"
+	},
+	"devDependencies": {
+		"find-up": "^6.2.0"
+	},
+	"scripts": {
+		"build": "tsup",
+		"dev": "tsup --watch src"
+	}
+}