@koishijs/client/lib/index.js

Koishi Console Client

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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  apply: () => apply,
  build: () => build2,
  createServer: () => createServer2,
  inject: () => inject
});
module.exports = __toCommonJS(src_exports);
var vite = __toESM(require("vite"));
var import_fs = require("fs");
var import_path = require("path");
var import_plugin_vue = __toESM(require("@vitejs/plugin-vue"));
var import_vite_plugin_yaml = __toESM(require("@maikolib/vite-plugin-yaml"));
async function build2(root, config = {}) {
  if (!(0, import_fs.existsSync)(root + "/client")) return;
  const outDir = root + "/dist";
  if ((0, import_fs.existsSync)(outDir)) {
    await import_fs.promises.rm(outDir, { recursive: true });
  }
  await import_fs.promises.mkdir(root + "/dist", { recursive: true });
  const results = await vite.build(vite.mergeConfig({
    root,
    build: {
      write: false,
      outDir: "dist",
      assetsDir: "",
      minify: true,
      emptyOutDir: true,
      commonjsOptions: {
        strictRequires: true
      },
      lib: {
        entry: root + "/client/index.ts",
        fileName: "index",
        formats: ["es"]
      },
      rollupOptions: {
        makeAbsoluteExternalsRelative: true,
        external: [
          "vue",
          "vue-router",
          "@vueuse/core",
          "@koishijs/client"
        ],
        output: {
          format: "iife"
        }
      }
    },
    plugins: [
      (0, import_plugin_vue.default)(),
      (0, import_vite_plugin_yaml.default)(),
      (await import("unocss/vite")).default({
        presets: [
          (await import("unocss/preset-mini")).default({
            preflight: false
          })
        ]
      })
    ],
    css: {
      preprocessorOptions: {
        scss: {
          api: "modern-compiler"
        }
      }
    },
    resolve: {
      alias: {
        "vue-i18n": "@koishijs/client",
        "@koishijs/components": "@koishijs/client"
      }
    },
    define: {
      "process.env.NODE_ENV": '"production"'
    }
  }, config));
  for (const item of results[0].output) {
    if (item.fileName === "index.mjs") item.fileName = "index.js";
    const dest = root + "/dist/" + item.fileName;
    if (item.type === "asset") {
      await import_fs.promises.writeFile(dest, item.source);
    } else {
      const result = await vite.transformWithEsbuild(item.code, dest, {
        minifyWhitespace: true,
        charset: "utf8"
      });
      await import_fs.promises.writeFile(dest, result.code);
    }
  }
}
__name(build2, "build");
async function createServer2(baseDir, config) {
  const root = (0, import_path.resolve)(__dirname, "../app");
  return vite.createServer(vite.mergeConfig({
    root,
    base: "/vite/",
    server: {
      middlewareMode: true,
      fs: {
        allow: [
          vite.searchForWorkspaceRoot(baseDir)
        ]
      }
    },
    plugins: [
      (0, import_plugin_vue.default)(),
      (0, import_vite_plugin_yaml.default)(),
      (await import("unocss/vite")).default({
        presets: [
          (await import("unocss/preset-mini")).default({
            preflight: false
          })
        ]
      })
    ],
    css: {
      preprocessorOptions: {
        scss: {
          api: "modern-compiler"
        }
      }
    },
    resolve: {
      dedupe: ["vue", "vue-demi", "vue-router", "element-plus", "@vueuse/core", "@popperjs/core", "marked", "xss"],
      alias: {
        // for backward compatibility
        "../client.js": "@koishijs/client",
        "../vue.js": "vue",
        "../vue-router.js": "vue-router",
        "../vueuse.js": "@vueuse/core"
      }
    },
    optimizeDeps: {
      include: [
        "vue",
        "vue-router",
        "element-plus",
        "@vueuse/core",
        "@popperjs/core",
        "marked",
        "xss"
      ]
    },
    build: {
      rollupOptions: {
        input: root + "/index.html"
      }
    }
  }, config));
}
__name(createServer2, "createServer");
var inject = ["yakumo"];
function apply(ctx) {
  ctx.register("client", async () => {
    const paths = ctx.yakumo.locate(ctx.yakumo.argv._);
    for (const path of paths) {
      const meta = ctx.yakumo.workspaces[path];
      const deps = {
        ...meta.dependencies,
        ...meta.devDependencies,
        ...meta.peerDependencies,
        ...meta.optionalDependencies
      };
      let config = {};
      if (meta.yakumo?.client) {
        const filename = (0, import_path.resolve)(ctx.yakumo.cwd + path, meta.yakumo.client);
        const exports2 = (await import(filename)).default;
        if (typeof exports2 === "function") {
          await exports2();
          continue;
        }
        config = exports2;
      } else if (!deps["@koishijs/client"]) {
        continue;
      }
      await build2(ctx.yakumo.cwd + path, config);
    }
  });
}
__name(apply, "apply");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  apply,
  build,
  createServer,
  inject
});
//# sourceMappingURL=index.js.map