kirbyup 2.0.1 → 2.0.2-beta.0

package/dist/cli.mjs

@@ -1,22 +1,21 @@
 import { cac } from 'cac';
-import { n as name, b as build, s as serve, v as version, h as handleError } from './shared/kirbyup.3c5fa7eb.mjs';
+import { n as name, b as build, s as serve, v as version, h as handleError } from './shared/kirbyup.d1711aad.mjs';
 import 'node:fs';
 import 'node:fs/promises';
 import 'pathe';
+import 'consola';
+import 'picocolors';
+import 'perfect-debounce';
 import 'vite';
-import 'fs';
-import 'path';
-import 'module';
-import 'crypto';
+import 'vue/compiler-sfc';
+import '@vitejs/plugin-vue2';
+import 'vite-plugin-full-reload';
 import 'postcss-load-config';
 import 'postcss-logical';
 import 'postcss-dir-pseudo-class';
-import 'consola';
-import 'perfect-debounce';
-import 'picocolors';
-import 'vite-plugin-full-reload';
 import 'zlib';
 import 'util';
+import 'fs';
 import 'unconfig';
 import 'magic-string';
 import 'detect-package-manager';

package/dist/index.mjs

@@ -1,21 +1,20 @@
 import 'node:fs';
 import 'node:fs/promises';
 import 'pathe';
+import 'consola';
+import 'picocolors';
+import 'perfect-debounce';
 import 'vite';
-export { b as build, s as serve } from './shared/kirbyup.3c5fa7eb.mjs';
+import 'vue/compiler-sfc';
+import '@vitejs/plugin-vue2';
+import 'vite-plugin-full-reload';
 import 'postcss-load-config';
 import 'postcss-logical';
 import 'postcss-dir-pseudo-class';
-import 'consola';
-import 'perfect-debounce';
-import 'picocolors';
-import 'vite-plugin-full-reload';
-import 'fs';
-import 'path';
-import 'module';
-import 'crypto';
+export { b as build, s as serve } from './shared/kirbyup.d1711aad.mjs';
 import 'zlib';
 import 'util';
+import 'fs';
 import 'unconfig';
 import 'magic-string';
 import 'detect-package-manager';

package/dist/shared/kirbyup.d1711aad.mjs

@@ -0,0 +1,385 @@
+import { existsSync as existsSync$1, unlinkSync } from 'node:fs';
+import { writeFile, readFile } from 'node:fs/promises';
+import { normalize, relative, resolve, dirname, basename } from 'pathe';
+import consola from 'consola';
+import colors from 'picocolors';
+import { debounce } from 'perfect-debounce';
+import { createServer, mergeConfig, build as build$1 } from 'vite';
+import * as vueCompilerSfc from 'vue/compiler-sfc';
+import vuePlugin, { parseVueRequest } from '@vitejs/plugin-vue2';
+import fullReloadPlugin from 'vite-plugin-full-reload';
+import postcssrc from 'postcss-load-config';
+import postcssLogical from 'postcss-logical';
+import postcssDirPseudoClass from 'postcss-dir-pseudo-class';
+import { gzip } from 'zlib';
+import { promisify } from 'util';
+import { existsSync, statSync } from 'fs';
+import { createConfigLoader } from 'unconfig';
+import MagicString from 'magic-string';
+import { detect } from 'detect-package-manager';
+
+const name = "kirbyup";
+const version = "2.0.2-beta.0";
+
+class PrettyError 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) {
+  consola.error(error.message);
+  process.exitCode = 1;
+}
+
+function toArray(array) {
+  array = array || [];
+  if (Array.isArray(array))
+    return array;
+  return [array];
+}
+const compress = promisify(gzip);
+async function getCompressedSize(code) {
+  const size = (await compress(typeof code === "string" ? code : Buffer.from(code))).length / 1024;
+  return ` / gzip: ${size.toFixed(2)} KiB`;
+}
+async function printFileInfo(root, outDir, filePath, content, type, maxLength) {
+  const prettyOutDir = `${normalize(relative(root, resolve(root, outDir)))}/`;
+  const kibs = content.length / 1024;
+  const compressedSize = await getCompressedSize(content);
+  const writeColor = type === "chunk" ? colors.cyan : colors.magenta;
+  consola.log(
+    colors.white(colors.dim(prettyOutDir)) + writeColor(filePath.padEnd(maxLength + 2)) + colors.dim(`${kibs.toFixed(2)} KiB${compressedSize}`)
+  );
+}
+
+async function loadConfig(cwd = process.cwd(), configOrPath = cwd, extraConfigSources = []) {
+  let inlineConfig = {};
+  if (typeof configOrPath !== "string") {
+    inlineConfig = configOrPath;
+    if (inlineConfig.configFile === false) {
+      return {
+        config: inlineConfig,
+        sources: []
+      };
+    } else {
+      configOrPath = inlineConfig.configFile || process.cwd();
+    }
+  }
+  const resolved = resolve(configOrPath);
+  let isFile = false;
+  if (existsSync(resolved) && statSync(resolved).isFile()) {
+    isFile = true;
+    cwd = dirname(resolved);
+  }
+  const loader = createConfigLoader({
+    sources: isFile ? [
+      {
+        files: resolved,
+        extensions: []
+      }
+    ] : [
+      {
+        files: ["kirbyup.config"]
+      },
+      ...extraConfigSources
+    ],
+    cwd,
+    defaults: inlineConfig
+  });
+  const result = await loader.load();
+  result.config = result.config || inlineConfig;
+  return result;
+}
+
+const multilineCommentsRE = /\/\*(.|[\r\n])*?\*\//gm;
+const singlelineCommentsRE = /\/\/.*/g;
+
+function kirbyupAutoImportPlugin() {
+  let config;
+  return {
+    name: "kirbyup:auto-import",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    async transform(code) {
+      if (code.includes("kirbyup.import")) {
+        const kirbyupImportRE = /\bkirbyup\.import\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*\)/g;
+        const noCommentsCode = code.replace(multilineCommentsRE, (m) => " ".repeat(m.length)).replace(singlelineCommentsRE, (m) => " ".repeat(m.length));
+        let s = null;
+        let match;
+        while (match = kirbyupImportRE.exec(noCommentsCode)) {
+          const { 0: exp, 1: rawPath, index } = match;
+          if (!s)
+            s = new MagicString(code);
+          s.overwrite(
+            index,
+            index + exp.length,
+            `kirbyup.import(import.meta.glob(${rawPath}, { eager: true }))`
+          );
+        }
+        if (s) {
+          return {
+            code: s.toString(),
+            map: config.build.sourcemap ? s.generateMap({ hires: true }) : null
+          };
+        }
+      }
+      return null;
+    }
+  };
+}
+
+const __HMR_CODE__ = `
+if (typeof __VUE_HMR_RUNTIME__ !== 'undefined' && import.meta.hot) {
+  __VUE_HMR_RUNTIME__.reload = () => import.meta.hot.invalidate();
+}`.trim();
+const getViteProxyModule = (entryUrl, pm) => `
+try {
+  await import("${entryUrl}");
+} catch (err) {
+  console.error(
+    "[kirbyup] Couldn't connect to the development server. Run \`${pm} run serve\` to start Vite or build the plugin with \`${pm} run build\` so Kirby uses the production version."
+  );
+  throw err;
+}`.trim();
+function kirbyupHmrPlugin(options) {
+  let config;
+  let entry;
+  let indexMjs;
+  return {
+    name: "kirbyup:hmr",
+    apply: "serve",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+      entry = resolve(config.root, options.entry);
+      indexMjs = resolve(config.root, options.outDir || "", "index.dev.mjs");
+    },
+    transform(code, id) {
+      const { query } = parseVueRequest(id);
+      if (query.raw)
+        return;
+      if ((typeof id !== "string" || /\0/.test(id)) && !query.vue)
+        return;
+      if (/\.vue$/.test(id) && !query.vue)
+        return `${code};${__HMR_CODE__}`;
+    },
+    configureServer(server) {
+      if (!server.httpServer)
+        return;
+      server.httpServer.once("listening", async () => {
+        const entryPath = entry.replace(`${config.root}/`, "");
+        const { address, family, port } = server.httpServer.address();
+        const hostname = family === "IPv6" ? `[${address}]` : address;
+        const baseUrl = `http://${hostname}:${port}${config.base}`;
+        const entryUrl = new URL(entryPath, baseUrl).href;
+        const pm = await detect().catch(() => "npm");
+        await writeFile(indexMjs, getViteProxyModule(entryUrl, pm));
+      });
+    },
+    closeBundle() {
+      if (existsSync$1(indexMjs))
+        unlinkSync(indexMjs);
+    }
+  };
+}
+
+function kirbyupBuildCleanupPlugin(options) {
+  let config;
+  let indexMjs;
+  return {
+    name: "kirbyup:build-cleanup",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+      indexMjs = resolve(config.root, options.outDir, "index.dev.mjs");
+    },
+    writeBundle() {
+      if (existsSync$1(indexMjs))
+        unlinkSync(indexMjs);
+    }
+  };
+}
+
+let resolvedKirbyupConfig;
+let resolvedPostCssConfig;
+function getViteConfig(command, options) {
+  const aliasDir = resolve(options.cwd, dirname(options.entry));
+  const { alias = {}, extendViteConfig = {} } = resolvedKirbyupConfig;
+  const baseConfig = {
+    resolve: {
+      alias: { "~/": `${aliasDir}/`, "@/": `${aliasDir}/`, ...alias }
+    },
+    plugins: [
+      vuePlugin({ compiler: vueCompilerSfc }),
+      kirbyupAutoImportPlugin()
+    ],
+    css: { postcss: resolvedPostCssConfig },
+    envPrefix: ["VITE_", "KIRBYUP_"],
+    logLevel: "warn"
+  };
+  if (command === "serve") {
+    const { port, watch } = options;
+    const serveConfig = mergeConfig(baseConfig, {
+      plugins: [
+        kirbyupHmrPlugin(options),
+        watch && fullReloadPlugin(watch)
+      ],
+      build: { rollupOptions: { input: resolve(options.cwd, options.entry) } },
+      server: { port, strictPort: true, origin: `http://localhost:${port}` }
+    });
+    return mergeConfig(serveConfig, extendViteConfig);
+  }
+  const mode = options.watch ? "development" : "production";
+  const buildConfig = mergeConfig(baseConfig, {
+    plugins: [kirbyupBuildCleanupPlugin(options)],
+    mode,
+    build: {
+      lib: {
+        entry: resolve(options.cwd, options.entry),
+        formats: ["iife"],
+        name: "kirbyupExport",
+        fileName: () => "index.js"
+      },
+      minify: mode === "production",
+      outDir: options.outDir,
+      emptyOutDir: false,
+      rollupOptions: {
+        external: ["vue"],
+        output: {
+          assetFileNames: "index.[ext]",
+          globals: { vue: "Vue" }
+        }
+      }
+    }
+  });
+  return mergeConfig(buildConfig, extendViteConfig);
+}
+async function generate(options) {
+  const config = getViteConfig("build", options);
+  let result;
+  try {
+    result = await build$1(config);
+  } catch (error) {
+    consola.error("Build failed");
+    if (config.mode === "production")
+      throw error;
+  }
+  if (result && !options.watch) {
+    const { output } = toArray(result)[0];
+    let longest = 0;
+    for (const file in output) {
+      const l = output[file].fileName.length;
+      if (l > longest)
+        longest = l;
+    }
+    for (const {
+      fileName,
+      type,
+      code
+    } of output) {
+      await printFileInfo(
+        options.cwd,
+        options.outDir,
+        fileName,
+        code ?? await readFile(resolve(options.outDir, fileName), "utf8"),
+        type,
+        longest
+      );
+    }
+  }
+  return result;
+}
+async function build(options) {
+  ensureEntry(options);
+  const { cwd } = options;
+  const { config, sources: configSources } = await loadConfig(cwd);
+  resolvedKirbyupConfig = config;
+  try {
+    resolvedPostCssConfig = await postcssrc({});
+  } catch (err) {
+    if (!/No PostCSS Config found/.test(err.message))
+      throw err;
+    resolvedPostCssConfig = {
+      plugins: [postcssLogical(), postcssDirPseudoClass()]
+    };
+  }
+  {
+    consola.log(colors.green(`${name} v${version}`));
+    consola.start(`Building ${colors.cyan(options.entry)}`);
+  }
+  if (options.watch)
+    consola.info("Running in watch mode");
+  const debouncedBuild = debounce(async () => {
+    generate(options).catch(handleError);
+  }, 100);
+  const startWatcher = async () => {
+    if (!options.watch)
+      return;
+    const { watch } = await import('chokidar');
+    const ignored = [
+      "**/{.git,node_modules}/**",
+      "index.{css,js}"
+    ];
+    const watchPaths = typeof options.watch === "boolean" ? dirname(options.entry) : Array.isArray(options.watch) ? options.watch.filter(
+      (path) => typeof path === "string"
+    ) : options.watch;
+    consola.info(
+      `Watching for changes in ${toArray(watchPaths).map((i) => colors.cyan(i)).join(", ")}`
+    );
+    const watcher = watch(watchPaths, {
+      ignoreInitial: true,
+      ignorePermissionErrors: true,
+      ignored,
+      cwd
+    });
+    if (configSources.length)
+      watcher.add(configSources);
+    watcher.on("all", async (type, file) => {
+      if (configSources.includes(file)) {
+        resolvedKirbyupConfig = (await loadConfig()).config;
+        consola.info(
+          `${colors.cyan(basename(file))} changed, setting new config`
+        );
+      } else {
+        consola.log(`${colors.green(type)} ${colors.white(colors.dim(file))}`);
+      }
+      debouncedBuild();
+    });
+  };
+  await generate(options);
+  consola.success("Build successful");
+  startWatcher();
+}
+async function serve(options) {
+  ensureEntry(options);
+  const { cwd } = options;
+  const { config } = await loadConfig(cwd);
+  resolvedKirbyupConfig = config;
+  try {
+    resolvedPostCssConfig = await postcssrc({});
+  } catch (err) {
+    if (!/No PostCSS Config found/.test(err.message))
+      throw err;
+    resolvedPostCssConfig = {
+      plugins: [postcssLogical(), postcssDirPseudoClass()]
+    };
+  }
+  {
+    consola.log(colors.green(`${name} v${version}`));
+    consola.info("Starting development server...");
+  }
+  const server = await createServer(getViteConfig("serve", options));
+  await server.listen();
+  consola.success(`Server is listening on :${server.config.server.port}`);
+  return server;
+}
+function ensureEntry(options) {
+  if (!existsSync$1(resolve(options.cwd, options.entry)))
+    throw new PrettyError(`Cannot find "${options.entry}"`);
+}
+
+export { build as b, handleError as h, name as n, serve as s, version as v };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kirbyup",
-  "version": "2.0.1",
-  "packageManager": "pnpm@7.9.4",
+  "version": "2.0.2-beta.0",
+  "packageManager": "pnpm@7.12.1",
   "description": "Zero-config bundler for Kirby Panel plugins",
   "author": {
     "name": "Johann Schopplich",
@@ -70,44 +70,39 @@
     "prepare": "simple-git-hooks"
   },
   "dependencies": {
+    "@vitejs/plugin-vue2": "^2.0.0",
     "@vue/compiler-sfc": "^2.7.10",
-    "cac": "^6.7.12",
+    "cac": "^6.7.14",
     "chokidar": "^3.5.3",
     "consola": "^2.15.3",
     "detect-package-manager": "^2.0.1",
-    "magic-string": "^0.26.2",
-    "pathe": "^0.3.5",
+    "magic-string": "^0.26.5",
+    "pathe": "^0.3.8",
     "perfect-debounce": "^0.1.3",
     "picocolors": "^1.0.0",
-    "postcss": "^8.4.16",
+    "postcss": "^8.4.17",
     "postcss-dir-pseudo-class": "^6.0.5",
     "postcss-load-config": "^4.0.1",
     "postcss-logical": "^5.0.4",
-    "sass": "^1.54.5",
-    "unconfig": "^0.3.5",
-    "vite": "^3.0.9",
+    "sass": "^1.55.0",
+    "unconfig": "^0.3.6",
+    "vite": "^3.1.4",
     "vite-plugin-full-reload": "^1.0.4",
     "vue": "^2.7.10"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^0.26.1",
+    "@antfu/eslint-config": "^0.27.0",
     "@types/fs-extra": "^9.0.13",
-    "@types/node": "^18.7.11",
+    "@types/node": "^18.7.23",
     "@types/prompts": "^2.4.0",
-    "@vitejs/plugin-vue2": "^1.1.2",
     "bumpp": "^8.2.1",
-    "eslint": "^8.22.0",
-    "fast-glob": "^3.2.11",
+    "eslint": "^8.24.0",
+    "fast-glob": "^3.2.12",
     "fs-extra": "^10.1.0",
     "simple-git-hooks": "^2.8.0",
-    "typescript": "^4.7.4",
-    "unbuild": "^0.8.9",
-    "vitest": "^0.22.1"
-  },
-  "pnpm": {
-    "patchedDependencies": {
-      "@vitejs/plugin-vue2@1.1.2": "patches/@vitejs__plugin-vue2@1.1.2.patch"
-    }
+    "typescript": "^4.8.4",
+    "unbuild": "^0.8.11",
+    "vitest": "^0.23.4"
   },
   "simple-git-hooks": {
     "commit-msg": "node scripts/verifyCommit.mjs $1"