kirbyup 0.1.0

package/dist/index.js

@@ -0,0 +1,197 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __require = typeof require !== "undefined" ? require : (x) => {
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+};
+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);
+};
+
+// src/index.ts
+__export(exports, {
+  build: () => build,
+  runViteBuild: () => runViteBuild
+});
+
+// node_modules/tsup/assets/cjs_shims.js
+var importMetaUrlShim = typeof document === "undefined" ? new (require("url")).URL("file:" + __filename).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
+
+// src/index.ts
+var import_fs = __toModule(require("fs"));
+var import_path = __toModule(require("path"));
+var import_vite = __toModule(require("vite"));
+var import_vite_plugin_vue2 = __toModule(require("vite-plugin-vue2"));
+
+// src/errors.ts
+var import_worker_threads = __toModule(require("worker_threads"));
+var import_chalk = __toModule(require("chalk"));
+var PrettyError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, this.constructor);
+    } else {
+      this.stack = new Error(message).stack;
+    }
+  }
+};
+function handleError(error) {
+  if (error.loc) {
+    console.error(import_chalk.default.bold(import_chalk.default.red(`Error parsing: ${error.loc.file}:${error.loc.line}:${error.loc.column}`)));
+  }
+  if (error.frame) {
+    console.error(import_chalk.default.red(error.message));
+    console.error(import_chalk.default.dim(error.frame));
+  } else {
+    if (error instanceof PrettyError) {
+      console.error(import_chalk.default.red(error.message));
+    } else {
+      console.error(import_chalk.default.red(error.stack));
+    }
+  }
+  process.exitCode = 1;
+  if (!import_worker_threads.isMainThread && import_worker_threads.parentPort) {
+    import_worker_threads.parentPort.postMessage("has-error");
+  }
+}
+
+// src/utils.ts
+function debouncePromise(fn, delay, onError) {
+  let timeout;
+  let promiseInFly;
+  let callbackPending;
+  return function debounced(...args) {
+    if (promiseInFly) {
+      callbackPending = () => {
+        debounced(...args);
+        callbackPending = void 0;
+      };
+    } else {
+      if (timeout != null)
+        clearTimeout(timeout);
+      timeout = setTimeout(() => {
+        timeout = void 0;
+        promiseInFly = fn(...args).catch(onError).finally(() => {
+          promiseInFly = void 0;
+          if (callbackPending)
+            callbackPending();
+        });
+      }, delay);
+    }
+  };
+}
+
+// src/log.ts
+var import_chalk2 = __toModule(require("chalk"));
+var label = import_chalk2.default.gray("[kirbyup]");
+var makeMessage = (input, type) => import_chalk2.default[type === "info" ? "yellow" : type === "error" ? "red" : "green"](input);
+function log(type, message) {
+  switch (type) {
+    case "error": {
+      return console.error(label, makeMessage(message, type));
+    }
+    default:
+      console.log(label, makeMessage(message, type));
+  }
+}
+
+// package.json
+var version = "0.1.0";
+
+// src/index.ts
+async function runViteBuild(options) {
+  let result;
+  try {
+    result = await (0, import_vite.build)({
+      plugins: [(0, import_vite_plugin_vue2.createVuePlugin)()],
+      build: {
+        lib: {
+          entry: import_path.default.resolve(__dirname, options.entry),
+          formats: ["es"]
+        },
+        outDir: ".",
+        rollupOptions: {
+          external: ["vue"],
+          output: {
+            entryFileNames: `[name].js`,
+            assetFileNames: `index.[ext]`,
+            globals: {
+              vue: "Vue"
+            }
+          }
+        }
+      },
+      logLevel: "error"
+    });
+  } catch (error) {
+    log("error", "Build failed");
+    throw error;
+  }
+  if (result) {
+    log("success", `Build success`);
+  }
+  return result;
+}
+var normalizeOptions = async (options) => {
+  if (!options.entry) {
+    throw new PrettyError(`No input file, try "kirbyup <path/to/file.js>"`);
+  }
+  if (!import_fs.default.existsSync(options.entry)) {
+    throw new PrettyError(`Cannot find ${options.entry}`);
+  }
+  return options;
+};
+async function build(_options) {
+  const options = await normalizeOptions(_options);
+  log("info", `kirbyup v${version}`);
+  log("info", `Building: ${options.entry}`);
+  if (options.watch) {
+    log("info", "Running in watch mode");
+  }
+  const debouncedBuildAll = debouncePromise(async () => {
+    runViteBuild(options);
+  }, 100, handleError);
+  const startWatcher = async () => {
+    if (!options.watch)
+      return;
+    const { watch } = await import("chokidar");
+    const ignored = ["**/{.git,node_modules}/**"];
+    const watchPaths = typeof options.watch === "boolean" ? import_path.default.dirname(options.entry) : Array.isArray(options.watch) ? options.watch.filter((path2) => typeof path2 === "string") : options.watch;
+    log("info", `Watching for changes in ${Array.isArray(watchPaths) ? watchPaths.map((v) => '"' + v + '"').join(" | ") : '"' + watchPaths + '"'}`);
+    const watcher = watch(watchPaths, {
+      ignoreInitial: true,
+      ignorePermissionErrors: true,
+      ignored
+    });
+    watcher.on("all", async (type, file) => {
+      log("info", `Change detected: ${type} ${file}`);
+      debouncedBuildAll();
+    });
+  };
+  await runViteBuild(options);
+  startWatcher();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build,
+  runViteBuild
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "kirbyup",
+  "version": "0.1.0",
+  "description": "Bundle your Kirby Panel plugins with ease",
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "bin": {
+    "kirbyup": "dist/cli-default.js"
+  },
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/johannschopplich/kirbyup.git"
+  },
+  "keywords": [
+    "kirby",
+    "bundler"
+  ],
+  "author": {
+    "name": "Johann Schopplich",
+    "email": "pkg@johannschopplich.com",
+    "url": "https://johannschopplich.com"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/johannschopplich/kirbyup/issues"
+  },
+  "homepage": "https://github.com/johannschopplich/kirbyup#readme",
+  "scripts": {
+    "build": "tsup src/cli-*.ts src/index.ts --target node14 --clean --dts-resolve",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "cac": "^6.7.3",
+    "chalk": "^4.1.2",
+    "chokidar": "^3.5.2",
+    "prettier": "^2.4.1",
+    "ts-essentials": "^8.1.0",
+    "tsup": "^5.1.0",
+    "vite": "^2.5.7",
+    "vite-plugin-vue2": "^1.8.2",
+    "vue": "^2.6.14"
+  },
+  "devDependencies": {
+    "@types/node": "^16.9.1",
+    "typescript": "^4.4.3"
+  }
+}