kirbyup 3.3.0 → 3.4.0

package/README.md

@@ -46,7 +46,7 @@ Having installed kirbyup, you can add the following scripts as shortcuts to the
     "build": "kirbyup src/index.js"
   },
   "devDependencies": {
-    "kirbyup": "^3.1.3"
+    "kirbyup": "^3.4.0"
   }
 }
 ```

package/dist/node/cli.mjs

@@ -1,5 +1,5 @@
 import { cac } from 'cac';
-import { n as name, b as build, s as serve, v as version, h as handleError } from '../shared/kirbyup.BtejYnwg.mjs';
+import { n as name, b as build, s as serve, v as version, h as handleError } from '../shared/kirbyup.Bxmi3UeO.mjs';
 import 'node:fs';
 import 'node:fs/promises';
 import '@vitejs/plugin-vue2';
@@ -15,12 +15,7 @@ import 'vue/compiler-sfc';
 import 'c12';
 import 'postcss-load-config';
 import 'magic-string';
-import 'node:module';
-import 'child_process';
-import 'path';
-import 'process';
-import 'stream';
-import 'readline';
+import 'nypm';
 import 'node:buffer';
 import 'node:util';
 import 'node:zlib';

package/dist/node/index.mjs

@@ -10,16 +10,11 @@ import 'rollup-plugin-external-globals';
 import 'vite';
 import 'vite-plugin-full-reload';
 import 'vue/compiler-sfc';
-export { b as build, s as serve } from '../shared/kirbyup.BtejYnwg.mjs';
+export { b as build, s as serve } from '../shared/kirbyup.Bxmi3UeO.mjs';
 import 'c12';
 import 'postcss-load-config';
 import 'magic-string';
-import 'node:module';
-import 'child_process';
-import 'path';
-import 'process';
-import 'stream';
-import 'readline';
+import 'nypm';
 import 'node:buffer';
 import 'node:util';
 import 'node:zlib';

package/dist/shared/kirbyup.Bxmi3UeO.mjs

@@ -0,0 +1,449 @@
+import * as fs from 'node:fs';
+import * as fsp from 'node:fs/promises';
+import vuePlugin from '@vitejs/plugin-vue2';
+import vueJsxPlugin from '@vitejs/plugin-vue2-jsx';
+import { consola } from 'consola';
+import { colors } from 'consola/utils';
+import { resolve, normalize, relative, dirname, basename } from 'pathe';
+import { debounce } from 'perfect-debounce';
+import externalGlobals from 'rollup-plugin-external-globals';
+import { createLogger, createServer, build as build$1, mergeConfig } from 'vite';
+import fullReloadPlugin from 'vite-plugin-full-reload';
+import * as vueCompilerSfc from 'vue/compiler-sfc';
+import { loadConfig as loadConfig$1 } from 'c12';
+import postcssrc from 'postcss-load-config';
+import MagicString from 'magic-string';
+import { detectPackageManager } from 'nypm';
+import { Buffer } from 'node:buffer';
+import { promisify } from 'node:util';
+import { gzip } from 'node:zlib';
+
+const name = "kirbyup";
+const version = "3.4.0";
+
+function loadConfig(cwd = process.cwd()) {
+  return loadConfig$1({
+    cwd,
+    name: "kirbyup",
+    rcFile: false,
+    packageJson: false
+  });
+}
+async function resolvePostCSSConfig(cwd) {
+  try {
+    return await postcssrc(void 0, void 0, { stopDir: cwd });
+  } catch (error) {
+    if (!error.message.includes("No PostCSS Config found"))
+      throw error;
+  }
+}
+
+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 kirbyupBuildCleanupPlugin(options) {
+  let config;
+  let devIndexPath;
+  return {
+    name: "kirbyup:build-cleanup",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+      devIndexPath = resolve(config.root, options.outDir, "index.dev.mjs");
+    },
+    writeBundle() {
+      if (fs.existsSync(devIndexPath))
+        fs.unlinkSync(devIndexPath);
+    }
+  };
+}
+
+const multilineCommentsRE = /\/\*(.|[\r\n])*?\*\//g;
+const singlelineCommentsRE = /\/\/.*/g;
+const HMR_RUNTIME_ID = "\0plugin-vue2:hmr-runtime";
+const JSX_HMR_RUNTIME_ID = "plugin-vue2-jsx:hmr-runtime";
+function isHmrRuntimeId(id) {
+  return id === HMR_RUNTIME_ID || id === JSX_HMR_RUNTIME_ID;
+}
+const __INJECTED_HMR_CODE__ = `
+/** - injected by kirbyup - */
+for (const methodName of ['rerender', 'reload']) {
+  const original = __VUE_HMR_RUNTIME__[methodName]
+
+  __VUE_HMR_RUNTIME__[methodName] = function (id, updatedDef) {
+    const key = updatedDef?.__file ? '__file' : updatedDef?.__hmrId ? '__hmrId' : null
+
+    if (key) {
+      const pluginComponents = window.panel.plugins.components
+      // const usedComponentDefs = window.panel.app.$options.components
+      const usedComponentDefs = window.panel.app._vnode.componentInstance.$options.components // #33
+
+      for (const componentName in pluginComponents) {
+        if (updatedDef[key] === pluginComponents[componentName][key]) {
+          const usedDefinition = usedComponentDefs[componentName].options
+
+          if (map[id].options !== usedDefinition)
+            map[id].options = usedDefinition
+
+          if (typeof map[id].options.$_isSection !== 'boolean')
+            map[id].options.$_isSection = /^k-.*-section$/.test(componentName)
+
+          break
+        }
+      }
+    }
+
+    return original.apply(this, arguments)
+  }
+}
+
+function $_applyKirbyModifications(activeDef, newDef) {
+  const usedComponentDefs = window.panel.app.$options.components
+
+  if (newDef.template)
+    newDef.render = null
+
+  if (activeDef.$_isSection)
+    newDef.$_isSection = true
+  if (newDef.$_isSection && !newDef.mixins?.[0]?.methods?.load)
+    newDef.mixins = [activeDef.mixins[0], ...(newDef.mixins || [])]
+
+  if (typeof newDef.extends === 'string') {
+    if (newDef.extends === activeDef.extends?.options?.name) {
+      newDef.extends = activeDef.extends
+    }
+    else if (usedComponentDefs[newDef.extends]) {
+      newDef.extends = usedComponentDefs[newDef.extends].extend({
+        options: newDef,
+        components: { ...usedComponentDefs, ...(newDef.components || {}) },
+      })
+    }
+    else { newDef.extends = null }
+  }
+}
+/** -- */
+`;
+
+function kirbyupGlobImportPlugin() {
+  let config;
+  return {
+    name: "kirbyup:glob-import",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    async transform(code) {
+      if (!code.includes("kirbyup.import"))
+        return;
+      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;
+      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 }) : void 0
+        };
+      }
+    }
+  };
+}
+
+function kirbyupHmrPlugin(options) {
+  let config;
+  let entry;
+  let devIndexPath;
+  return {
+    name: "kirbyup:hmr",
+    apply: "serve",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+      entry = resolve(config.root, options.entry);
+      devIndexPath = resolve(config.root, options.outDir || "", "index.dev.mjs");
+    },
+    transform(code, id) {
+      if (isHmrRuntimeId(id)) {
+        return code.replace(
+          // https://github.com/vitejs/vite-plugin-vue2/blob/8de73ea6b8a1df4c14308da2885db195dacc2b14/src/utils/hmrRuntime.ts#L173
+          /^.*=\s*record\.Ctor\.super\.extend\(options\)/m,
+          "$_applyKirbyModifications(record.Ctor.options, options) // injected by kirbyup\n$&"
+        ) + __INJECTED_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 detectPackageManager(config.root);
+        await fsp.writeFile(devIndexPath, getViteProxyModule(entryUrl, pm));
+      });
+    },
+    closeBundle() {
+      if (fs.existsSync(devIndexPath))
+        fs.unlinkSync(devIndexPath);
+    }
+  };
+}
+function getViteProxyModule(entryUrl, packageManager) {
+  const pm = packageManager?.name || "npm";
+  return `
+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;
+}
+`.trimStart();
+}
+
+function toArray(array) {
+  array ??= [];
+  return Array.isArray(array) ? array : [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)} kB${compressedSize}`)
+  );
+}
+
+let resolvedKirbyupConfig;
+let resolvedPostCssConfig;
+const logLevel = "warn";
+const logger = createLogger(logLevel);
+const loggerWarn = logger.warn;
+logger.warn = (msg, options) => {
+  if (msg.includes("(!) build.outDir"))
+    return;
+  loggerWarn(msg, options);
+};
+function getViteConfig(command, options) {
+  const aliasDir = resolve(options.cwd, dirname(options.entry));
+  const { alias = {}, vite, extendViteConfig } = resolvedKirbyupConfig;
+  const userConfig = vite ?? extendViteConfig ?? {};
+  const sharedConfig = {
+    resolve: {
+      alias: {
+        "~/": `${aliasDir}/`,
+        "@/": `${aliasDir}/`,
+        ...alias
+      }
+    },
+    plugins: [
+      // Explicitly pass the compiler, since the plugin's resolving of the compiler
+      // looks in the current directory and breaks `npx kirbyup`
+      vuePlugin({ compiler: vueCompilerSfc }),
+      vueJsxPlugin(),
+      kirbyupGlobImportPlugin(),
+      { ...externalGlobals({ vue: "Vue" }), enforce: "post" }
+    ],
+    build: {
+      copyPublicDir: false
+    },
+    ...resolvedPostCssConfig && {
+      css: {
+        postcss: resolvedPostCssConfig
+      }
+    },
+    envDir: options.cwd,
+    envPrefix: ["VITE_", "KIRBYUP_"],
+    customLogger: logger,
+    logLevel
+  };
+  if (command === "serve") {
+    const { port, watch } = options;
+    const serveConfig = mergeConfig(sharedConfig, {
+      plugins: [
+        kirbyupHmrPlugin(options),
+        watch && fullReloadPlugin(watch)
+      ].filter(Boolean),
+      // Input needs to be specified so dependency pre-bundling works
+      build: {
+        rollupOptions: {
+          input: resolve(options.cwd, options.entry)
+        }
+      },
+      // Specify origin so asset URLs include Vite server host
+      server: {
+        port,
+        strictPort: true,
+        origin: `http://localhost:${port}`
+      }
+    });
+    return mergeConfig(serveConfig, userConfig);
+  }
+  const mode = options.watch ? "development" : "production";
+  const buildConfig = mergeConfig(sharedConfig, {
+    mode,
+    plugins: [kirbyupBuildCleanupPlugin(options)],
+    build: {
+      lib: {
+        entry: resolve(options.cwd, options.entry),
+        formats: ["iife"],
+        name: "kirbyupExport",
+        fileName: () => "index.js"
+      },
+      minify: mode === "production",
+      outDir: options.outDir,
+      emptyOutDir: false,
+      rollupOptions: {
+        output: {
+          assetFileNames: "index.[ext]"
+        }
+      }
+    }
+  });
+  return mergeConfig(buildConfig, userConfig);
+}
+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 maxLength = 0;
+    for (const chunkFile in output) {
+      const fileNameLength = output[chunkFile].fileName.length;
+      if (fileNameLength > maxLength)
+        maxLength = fileNameLength;
+    }
+    for (const { fileName, type, code } of output) {
+      const content = code || await fsp.readFile(resolve(options.outDir, fileName), "utf8");
+      await printFileInfo(
+        {
+          root: options.cwd,
+          outDir: options.outDir,
+          filePath: fileName,
+          content,
+          type,
+          maxLength
+        }
+      );
+    }
+  }
+  return result;
+}
+async function build(options) {
+  assertEntryExists(options);
+  const { cwd } = options;
+  const { config, configFile } = await loadConfig(cwd);
+  resolvedKirbyupConfig = config ?? {};
+  resolvedPostCssConfig = await resolvePostCSSConfig(cwd);
+  {
+    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}/**",
+      // Always ignore dist files
+      "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 (configFile)
+      watcher.add(configFile);
+    watcher.on("all", async (type, file) => {
+      const absolutePath = resolve(cwd, file);
+      if (configFile === absolutePath) {
+        resolvedKirbyupConfig = (await loadConfig(cwd)).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) {
+  assertEntryExists(options);
+  const { cwd } = options;
+  const { config } = await loadConfig(cwd);
+  resolvedKirbyupConfig = config ?? {};
+  resolvedPostCssConfig = await resolvePostCSSConfig(cwd);
+  {
+    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 assertEntryExists(options) {
+  if (!fs.existsSync(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,8 +1,8 @@
 {
   "name": "kirbyup",
   "type": "module",
-  "version": "3.3.0",
-  "packageManager": "pnpm@10.7.1",
+  "version": "3.4.0",
+  "packageManager": "pnpm@10.15.1",
   "description": "Zero-config bundler for Kirby Panel plugins",
   "author": {
     "name": "Johann Schopplich",
@@ -75,32 +75,32 @@
     "@vitejs/plugin-vue2": "2.2.0",
     "@vitejs/plugin-vue2-jsx": "1.1.0",
     "@vue/compiler-sfc": "^2.7.16",
-    "c12": "^3.0.3",
+    "c12": "^3.2.0",
     "cac": "^6.7.14",
-    "chokidar": "~3.6.0",
+    "chokidar": "^4.0.3",
     "consola": "^3.4.2",
-    "magic-string": "^0.30.17",
+    "magic-string": "^0.30.19",
+    "nypm": "^0.6.1",
     "pathe": "^2.0.3",
-    "perfect-debounce": "^1.0.0",
-    "postcss": "^8.5.3",
+    "perfect-debounce": "^2.0.0",
+    "postcss": "^8.5.6",
     "postcss-load-config": "^6.0.1",
     "rollup-plugin-external-globals": "^0.13.0",
-    "sass": "^1.86.3",
-    "vite": "~5.4.17",
+    "sass": "^1.92.1",
+    "vite": "~6.3.6",
     "vite-plugin-full-reload": "^1.2.0",
     "vue": "^2.7.16"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^4.11.0",
-    "@types/node": "^22.14.0",
+    "@antfu/eslint-config": "^5.3.0",
+    "@types/node": "^24.3.1",
     "@types/prompts": "^2.4.9",
-    "bumpp": "^10.1.0",
-    "eslint": "^9.24.0",
+    "bumpp": "^10.2.3",
+    "eslint": "^9.35.0",
     "fast-glob": "^3.3.3",
-    "nypm": "^0.6.0",
-    "typescript": "^5.8.3",
-    "unbuild": "^3.5.0",
-    "vitest": "^3.1.1"
+    "typescript": "^5.9.2",
+    "unbuild": "^3.6.1",
+    "vitest": "^3.2.4"
   },
   "pnpm": {
     "onlyBuiltDependencies": [