@aerogel/cli 0.0.0-next.b58141fee5d2fe7d25debdbca6b1d2bf1c13e48e → 0.0.0-next.bf95405357e75d2e8b0268a5e8ce7b2b7dd0c895

package/dist/aerogel-cli.js

@@ -0,0 +1,833 @@
+var Q = Object.defineProperty;
+var X = (o, e, t) => e in o ? Q(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var a = (o, e, t) => X(o, typeof e != "symbol" ? e + "" : e, t);
+import { Command as Z } from "commander";
+import { existsSync as N, lstatSync as O, readFileSync as z, readdirSync as G, mkdirSync as H, writeFileSync as ee } from "node:fs";
+import { facade as L, stringMatchAll as te, toString as ie, stringMatch as se, arrayFrom as I, stringToSlug as T, stringToTitleCase as ne, arrayFilter as ae, stringToStudlyCase as re, formatCodeBlock as M, stringToCamelCase as oe, fail as ce } from "@noeldemartin/utils";
+import { fileURLToPath as x, URL as S } from "node:url";
+import { resolve as J, dirname as W, basename as le } from "node:path";
+import P from "chalk";
+import { cursorTo as pe, clearLine as de } from "node:readline";
+import ue from "mustache";
+import { Project as ge, SyntaxKind as j, Node as d } from "ts-morph";
+import { exec as me } from "node:child_process";
+class fe {
+  contains(e, t) {
+    var i;
+    return !!((i = this.read(e)) != null && i.includes(t));
+  }
+  exists(e) {
+    return N(e);
+  }
+  isSymlink(e) {
+    return O(e).isSymbolicLink();
+  }
+  read(e) {
+    return this.isFile(e) ? z(e).toString() : null;
+  }
+  getFiles(e) {
+    const t = G(e, { withFileTypes: !0 }), i = [];
+    for (const s of t) {
+      const n = J(e, s.name);
+      s.isDirectory() ? i.push(...this.getFiles(n)) : i.push(n);
+    }
+    return i;
+  }
+  isDirectory(e) {
+    return this.exists(e) && O(e).isDirectory();
+  }
+  isFile(e) {
+    return this.exists(e) && O(e).isFile();
+  }
+  isEmptyDirectory(e) {
+    return this.isDirectory(e) ? this.getFiles(e).length === 0 : !1;
+  }
+  makeDirectory(e) {
+    H(e, { recursive: !0 });
+  }
+  write(e, t) {
+    N(W(e)) || H(W(e), { recursive: !0 }), ee(e, t);
+  }
+}
+const c = L(fe);
+class he {
+  constructor() {
+    a(this, "renderInfo", P.hex("#00ffff"));
+    a(this, "renderSuccess", P.hex("#00ff00"));
+    a(this, "renderError", P.hex("#ff0000"));
+  }
+  async animate(e, t) {
+    const i = (u = "", k = !1) => {
+      const E = this.renderInfo(this.renderMarkdown(e) + (k ? "..." : ".".repeat(s % 4))) + u;
+      this.stdout(E);
+    };
+    let s = 0;
+    i();
+    const n = setInterval(() => (s++, i()), 1e3), l = await t();
+    return clearInterval(n), i(`
+`, !0), l;
+  }
+  info(e) {
+    this.log(this.renderMarkdown(e), this.renderInfo);
+  }
+  error(e) {
+    this.log(this.renderMarkdown(e), this.renderError);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  fail(e) {
+    this.error(e), process.exit(1);
+  }
+  success(e) {
+    this.log(this.renderMarkdown(e), this.renderSuccess);
+  }
+  renderMarkdown(e) {
+    const t = te(e, /\*\*(.*)\*\*/g);
+    for (const i of t)
+      e = e.replace(i[0], P.bold(i[1]));
+    return e;
+  }
+  log(e, t) {
+    this.formatMessage(e).forEach((i) => {
+      this.logLine(t ? t(i) : i);
+    });
+  }
+  formatMessage(e) {
+    var t;
+    if (e[0] === `
+`) {
+      e = e.slice(1).trimEnd();
+      const i = e.split(`
+`), s = e.trim()[0] ?? "", n = ((t = i.find((l) => l.trim().length > 0)) == null ? void 0 : t.indexOf(s)) ?? 0;
+      return i.map((l) => l.slice(n));
+    }
+    return [e];
+  }
+  logLine(e) {
+    console.log(e);
+  }
+  stdout(e) {
+    pe(process.stdout, 0), de(process.stdout, 0), process.stdout.write(e);
+  }
+}
+const r = L(he);
+class f {
+  constructor(e) {
+    this.path = e;
+  }
+  static instantiate(e, t = "./", i = {}) {
+    return new f(e).instantiate(t, i);
+  }
+  instantiate(e, t = {}) {
+    const i = this.getFilenameReplacements(t), s = [];
+    e = `${e}/`.replace(/\/\//, "/");
+    for (const n of c.getFiles(this.path)) {
+      const l = Object.entries(i).reduce(
+        (E, [Y, _]) => E.replaceAll(Y, _),
+        n.substring(this.path.length + 1)
+      ), u = z(n).toString(), k = e + (l.endsWith(".template") ? l.slice(0, -9) : l);
+      c.write(k, ue.render(u, t, void 0, ["<%", "%>"])), s.push(k);
+    }
+    return s;
+  }
+  getFilenameReplacements(e, t = "") {
+    return Object.entries(e).reduce(
+      (i, [s, n]) => (typeof n == "object" ? Object.assign(
+        i,
+        this.getFilenameReplacements(n, `${s}.`)
+      ) : i[`[${t}${s}]`] = ie(n), i),
+      {}
+    );
+  }
+}
+function ye(o = "") {
+  if (c.contains(
+    x(new S(
+      /* @vite-ignore */
+      "../../../package.json",
+      import.meta.url
+    )),
+    '"packages/create-aerogel"'
+  ))
+    return J(x(new S(
+      /* @vite-ignore */
+      "../",
+      import.meta.url
+    )), o);
+  const e = c.read(
+    x(new S(
+      /* @vite-ignore */
+      "../../../../package.json",
+      import.meta.url
+    ))
+  ), t = se(e ?? "", /"@aerogel\/core": "file:(.*)\/aerogel-core-[\d.]*\.tgz"/), i = (t == null ? void 0 : t[1]) ?? r.fail("Could not determine base path");
+  return J(i, o);
+}
+function h(o) {
+  return r.fail(`Could not find ${o} pack file, did you run 'npm pack'?`);
+}
+function y(o) {
+  return c.getFiles(m(o)).find((e) => e.endsWith(".tgz")) ?? null;
+}
+function m(o) {
+  return ye(`../${o}`);
+}
+function w(o) {
+  return x(new S(
+    /* @vite-ignore */
+    `../templates/${o}`,
+    import.meta.url
+  ));
+}
+class ve {
+  constructor() {
+    a(this, "cwd", null);
+  }
+  setWorkingDirectory(e) {
+    this.cwd = e;
+  }
+  async run(e) {
+    await new Promise((t, i) => {
+      me(e, { cwd: this.cwd ?? void 0 }, (s) => {
+        if (s) {
+          i(s);
+          return;
+        }
+        t();
+      });
+    });
+  }
+}
+const p = L(ve);
+class we {
+  constructor() {
+    a(this, "project");
+    a(this, "modifiedFiles");
+    this.project = new ge({ tsConfigFilePath: "tsconfig.json" }), this.modifiedFiles = /* @__PURE__ */ new Set(), this.project.addSourceFilesAtPaths("src/**/*.ts"), this.project.addSourceFilesAtPaths("vite.config.ts"), this.project.addSourceFilesAtPaths("package.json");
+  }
+  addSourceFile(e) {
+    this.project.addSourceFilesAtPaths(e);
+  }
+  requireSourceFile(e) {
+    return this.project.getSourceFileOrThrow(e);
+  }
+  async format() {
+    await r.animate("Formatting modified files", async () => {
+      const e = c.exists("prettier.config.js") || c.contains("package.json", '"prettier": {'), t = c.exists(".eslintrc.js") || c.contains("package.json", '"eslintConfig"'), s = c.contains("package.json", '"prettier-eslint-cli"') ? (n) => p.run(`npx prettier-eslint ${n} --write`) : async (n) => {
+        e && await p.run(`npx prettier ${n} --write`), n.match(/\.(ts|js|vue)$/) && t && await p.run(`npx eslint ${n} --fix`);
+      };
+      await Promise.all(I(this.modifiedFiles).map(async (n) => s(n)));
+    });
+  }
+  async save(e) {
+    await e.save(), this.addModifiedFile(e.getFilePath());
+  }
+  addModifiedFile(e) {
+    this.modifiedFiles.add(e);
+  }
+}
+class K {
+  constructor(e, t = {}) {
+    this.name = e, this.options = t;
+  }
+  create(e) {
+    c.exists(e) && (!c.isDirectory(e) || !c.isEmptyDirectory(e)) && r.fail(`Folder at '${e}' already exists!`), f.instantiate(w("app"), e, {
+      app: {
+        name: this.name,
+        slug: T(this.name)
+      },
+      dependencies: this.getDependencies(),
+      contentPath: this.options.linkedLocal ? `${m("core")}/dist/**/*.js` : "./node_modules/@aerogel/core/dist/**/*.js"
+    });
+  }
+  edit() {
+    return new we();
+  }
+  getDependencies() {
+    const e = (t) => Object.entries(t).reduce(
+      (i, [s, n]) => Object.assign(i, { [s]: `file:${n}` }),
+      {}
+    );
+    return this.options.linkedLocal ? e({
+      aerogelCli: m("cli"),
+      aerogelCore: m("core"),
+      aerogelCypress: m("cypress"),
+      aerogelPluginI18n: m("plugin-i18n"),
+      aerogelPluginSoukai: m("plugin-soukai"),
+      aerogelVite: m("vite")
+    }) : this.options.local ? e({
+      aerogelCli: y("cli") ?? h("cli"),
+      aerogelCore: y("core") ?? h("core"),
+      aerogelCypress: y("cypress") ?? h("cypress"),
+      aerogelPluginI18n: y("plugin-i18n") ?? h("plugin-i18n"),
+      aerogelPluginSoukai: y("plugin-soukai") ?? h("plugin-soukai"),
+      aerogelVite: y("vite") ?? h("vite")
+    }) : {
+      aerogelCli: "next",
+      aerogelCore: "next",
+      aerogelCypress: "next",
+      aerogelPluginI18n: "next",
+      aerogelPluginSoukai: "next",
+      aerogelVite: "next"
+    };
+  }
+}
+class g {
+  static define(e) {
+    e = e.command(this.command).description(this.description);
+    for (const [t, i] of this.parameters)
+      e = e.argument(`<${t}>`, i);
+    for (const [t, i] of Object.entries(this.options)) {
+      const s = typeof i == "string" ? i : i.description, n = typeof i == "string" ? "string" : i.type ?? "string";
+      e = e.option(n === "boolean" ? `--${t}` : `--${t} <${n}>`, s);
+    }
+    e = e.action((...t) => this.run.call(this, ...t));
+  }
+  static async run(...e) {
+    const t = new this(...e);
+    await t.validate(), await t.run();
+  }
+  async validate() {
+  }
+  async run() {
+  }
+  assertAerogelOrDirectory(e) {
+    const t = c.read("package.json");
+    if (t != null && t.includes("@aerogel/core") || e && c.isDirectory(e))
+      return;
+    const i = e ? `${e} folder does not exist.` : "package.json does not contain @aerogel/core.";
+    r.fail(`${i} Are you sure this is an Aerogel app?`);
+  }
+}
+a(g, "command", ""), a(g, "description", ""), a(g, "parameters", []), a(g, "options", {});
+class $ extends g {
+  constructor(t, i = {}) {
+    super();
+    a(this, "path");
+    a(this, "options");
+    this.path = t, this.options = i;
+  }
+  async run() {
+    const t = this.path, i = this.options.name ?? ne(le(t));
+    p.setWorkingDirectory(t), await this.createApp(i, t), await this.installDependencies(), await this.initializeGit(), r.success(`
+
+            That's it! You can start working on **${i}** doing the following:
+
+                cd ${t}
+                npm run dev
+
+            Have fun!
+        `);
+  }
+  async createApp(t, i) {
+    r.info(`Creating **${t}**...`), new K(t, {
+      local: this.options.local,
+      linkedLocal: this.options.local && !this.options.copy
+    }).create(i);
+  }
+  async installDependencies() {
+    await r.animate("Installing dependencies", async () => {
+      await p.run("npm install");
+    });
+  }
+  async initializeGit() {
+    await r.animate("Initializing git", async () => {
+      await p.run("git init"), await p.run("git add ."), await p.run('git commit -m "Start"');
+    });
+  }
+}
+a($, "command", "create"), a($, "description", "Create AerogelJS app"), a($, "parameters", [["path", "Application path"]]), a($, "options", {
+  name: "Application name",
+  local: {
+    type: "boolean",
+    description: "Whether to create an app using local Aerogel packages (used for core development)"
+  },
+  copy: {
+    type: "boolean",
+    description: "Whether to create an app linked to local Aerogel packages (used in CI)"
+  }
+});
+function q() {
+  return new K("");
+}
+function ke() {
+  return c.contains("package.json", '"@aerogel/core": "file:');
+}
+function xe() {
+  return c.isSymlink("node_modules/@aerogel/core");
+}
+function v(o, e = {}) {
+  if (!o)
+    return;
+  const t = e.guard ?? (() => !0), i = e.validate ?? (() => !0), s = I(e.skip ?? []);
+  return o.forEachDescendant((n, l) => {
+    if (t(n) && i(n))
+      return n;
+    const u = n.getKind();
+    s.includes(u) && l.skip();
+  });
+}
+function R(o, e) {
+  if (!(!o || !e(o)))
+    return o;
+}
+class b extends g {
+  constructor(t, i = {}) {
+    super();
+    a(this, "path");
+    a(this, "options");
+    this.path = t, this.options = i;
+  }
+  async validate() {
+    ae([this.options.button, this.options.input, this.options.checkbox]).length > 1 && r.fail("Can only use one of 'button', 'input', or 'checkbox' flags!");
+  }
+  async run() {
+    this.assertAerogelOrDirectory("src/components"), this.assertHistoireInstalled();
+    const t = /* @__PURE__ */ new Set(), [i, s] = this.parsePathComponents();
+    await this.createComponent(i, s, t), await this.createStory(i, s, t), await this.declareComponents();
+    const n = I(t).map((l) => `- ${l}`).join(`
+`);
+    r.info(`${s} component created successfully! The following files were created:
+
+${n}`);
+  }
+  assertHistoireInstalled() {
+    this.options.story && !c.contains("package.json", '"histoire"') && !c.contains("package.json", '"@aerogel/histoire"') && r.fail(`
+                Histoire is not installed yet! You can install it running:
+                npx gel install histoire
+            `);
+  }
+  async createComponent(t, i, s) {
+    await r.animate("Creating component", async () => {
+      c.exists(`src/components/${this.path}.vue`) && r.fail(`${this.path} component already exists!`);
+      const n = this.options.input ? "component-input" : this.options.button ? "component-button" : this.options.checkbox ? "component-checkbox" : "component";
+      f.instantiate(w(n), `src/components/${t}`, {
+        component: {
+          name: i,
+          slug: T(i)
+        }
+      }).forEach((u) => s.add(u));
+    });
+  }
+  async createStory(t, i, s) {
+    this.options.story && await r.animate("Creating story", async () => {
+      const n = this.options.input ? "component-input-story" : this.options.button ? "component-button-story" : this.options.checkbox ? "component-checkbox-story" : "component-story";
+      f.instantiate(w(n), `src/components/${t}`, {
+        component: {
+          name: i,
+          slug: T(i)
+        }
+      }).forEach((u) => s.add(u));
+    });
+  }
+  async declareComponents() {
+    const t = q().edit(), i = t.requireSourceFile("vite.config.ts"), s = this.getComponentDirsArray(i);
+    if (!s)
+      return r.fail("Could not find component dirs declaration in vite config!");
+    s.getDescendantsOfKind(j.StringLiteral).some((n) => n.getText() === "'src/components'") || (await r.animate("Updating vite config", async () => {
+      s.addElement("'src/components'"), await t.save(i);
+    }), await t.format());
+  }
+  getComponentDirsArray(t) {
+    const i = v(t, {
+      guard: d.isCallExpression,
+      validate: (l) => l.getText().startsWith("Components("),
+      skip: j.ImportDeclaration
+    });
+    if (!i)
+      return null;
+    const s = v(i, {
+      guard: d.isPropertyAssignment,
+      validate: (l) => l.getName() === "dirs"
+    }), n = s == null ? void 0 : s.getInitializer();
+    return d.isArrayLiteralExpression(n) ? n : this.declareComponentDirsArray(i);
+  }
+  declareComponentDirsArray(t) {
+    const i = v(t, { guard: d.isObjectLiteralExpression }), s = i == null ? void 0 : i.addPropertyAssignment({
+      name: "dirs",
+      initializer: "[]"
+    });
+    return (s == null ? void 0 : s.getInitializer()) ?? null;
+  }
+  parsePathComponents() {
+    const t = this.path.lastIndexOf("/");
+    return t === -1 ? ["", this.path] : [this.path.substring(0, t), this.path.substring(t + 1)];
+  }
+}
+a(b, "command", "generate:component"), a(b, "description", "Generate an AerogelJS Component"), a(b, "parameters", [
+  ["path", "Component path (relative to components folder; extension not necessary)"]
+]), a(b, "options", {
+  button: {
+    description: "Create a custom button",
+    type: "boolean"
+  },
+  checkbox: {
+    description: "Create a custom checkbox",
+    type: "boolean"
+  },
+  input: {
+    description: "Create a custom input",
+    type: "boolean"
+  },
+  story: {
+    description: "Create component story using Histoire",
+    type: "boolean"
+  }
+});
+class F extends g {
+  constructor(t, i = {}) {
+    super();
+    a(this, "name");
+    a(this, "options");
+    this.name = t, this.options = i;
+  }
+  async run() {
+    this.assertAerogelOrDirectory("src/models"), c.exists(`src/models/${this.name}.ts`) && r.fail(`${this.name} model already exists!`), this.assertSoukaiInstalled();
+    const t = await r.animate("Creating model", async () => f.instantiate(w("model"), "src/models", {
+      model: {
+        name: this.name,
+        fieldsDefinition: this.getFieldsDefinition()
+      },
+      soukaiImports: this.options.fields ? "FieldType, defineModelSchema" : "defineModelSchema"
+    }).map((s) => `- ${s}`).join(`
+`));
+    r.info(`${this.name} model created successfully! The following files were created:
+
+${t}`);
+  }
+  getFieldsDefinition() {
+    if (!this.options.fields)
+      return "        //";
+    const t = this.options.fields.split(",").map((i) => {
+      const [s, n, l] = i.split(":");
+      return {
+        name: s,
+        type: re(n ?? "string"),
+        required: l === "required"
+      };
+    }).reduce((i, s) => {
+      const n = s.required ? M(`
+                        ${s.name}: {
+                            type: FieldType.${s.type},
+                            required: true,
+                        }
+                    `) : `${s.name}: FieldType.${s.type}`;
+      return i + `
+${n},`;
+    }, "");
+    return M(t, { indent: 8 });
+  }
+  assertSoukaiInstalled() {
+    !c.contains("package.json", '"soukai"') && !c.contains("package.json", '"@aerogel/plugin-soukai"') && r.fail(`
+                Soukai is not installed yet! You can install it running:
+                npx gel install soukai
+            `);
+  }
+}
+a(F, "command", "generate:model"), a(F, "description", "Generate an AerogelJS Model"), a(F, "parameters", [["name", "Model name"]]), a(F, "options", {
+  fields: "Create model with the given fields"
+});
+class D extends g {
+  constructor(t = {}) {
+    super();
+    a(this, "options");
+    this.options = t;
+  }
+  async run() {
+    this.assertAerogelOrDirectory("src/components"), this.assertHistoireInstalled();
+    const t = /* @__PURE__ */ new Set();
+    await this.createComponents(t), await this.createStory(t);
+    const i = I(t).map((s) => `- ${s}`).join(`
+`);
+    r.info(`Overrides created successfully! The following files were created:
+
+${i}`), r.info(`
+Remember to declare your components in main.ts and main.histoire.ts!`);
+  }
+  assertHistoireInstalled() {
+    this.options.story && !c.contains("package.json", '"histoire"') && !c.contains("package.json", '"@aerogel/histoire"') && r.fail(`
+                Histoire is not installed yet! You can install it running:
+                npx gel install histoire
+            `);
+  }
+  async createComponents(t) {
+    await r.animate("Creating components", async () => {
+      c.exists("src/components/ModalWrapper.vue") && r.fail("ModalWrapper component already exists!"), f.instantiate(w("overrides"), "src").forEach((i) => t.add(i));
+    });
+  }
+  async createStory(t) {
+    this.options.story && await r.animate("Creating story", async () => {
+      f.instantiate(w("overrides-story"), "src/components/overrides/").forEach((i) => t.add(i));
+    });
+  }
+}
+a(D, "command", "generate:overrides"), a(D, "description", "Generate AerogelJS component overrides"), a(D, "options", {
+  story: {
+    description: "Create overrides story using Histoire",
+    type: "boolean"
+  }
+});
+class C extends g {
+  constructor(t) {
+    super();
+    a(this, "name");
+    this.name = t;
+  }
+  async run() {
+    this.assertAerogelOrDirectory("src/services");
+    const t = /* @__PURE__ */ new Set(), i = q().edit();
+    await this.createService(t), await this.registerService(i), await i.format();
+    const s = I(t).map((n) => `- ${n}`).join(`
+`);
+    r.info(`${this.name} service created successfully! The following files were created:
+
+${s}`);
+  }
+  async createService(t) {
+    await r.animate("Creating service", async () => {
+      c.exists(`src/services/${this.name}.ts`) && r.fail(`${this.name} service already exists!`), f.instantiate(w("service"), "src/services", {
+        service: {
+          name: this.name
+        }
+      }).forEach((s) => t.add(s));
+    });
+  }
+  async registerService(t) {
+    await r.animate("Registering service", async () => {
+      c.exists("src/services/index.ts") || await this.createServicesIndex(t);
+      const i = t.requireSourceFile("src/services/index.ts"), s = this.getServicesObject(i);
+      if (!s)
+        return r.fail("Could not find services object in services config, please add it manually.");
+      i.addImportDeclaration({
+        defaultImport: this.name,
+        moduleSpecifier: `./${this.name}`
+      }), s.addPropertyAssignment({
+        name: `$${oe(this.name)}`,
+        initializer: this.name
+      }), await t.save(i);
+    });
+  }
+  async createServicesIndex(t) {
+    c.write(
+      "src/services/index.ts",
+      M(`
+                export const services = {};
+
+                export type AppServices = typeof services;
+
+                declare module '@aerogel/core' {
+                    interface Services extends AppServices {}
+                }
+            `)
+    ), t.addSourceFile("src/services/index.ts");
+    const i = t.requireSourceFile("src/main.ts"), s = this.getBootstrapOptions(i);
+    if (!s)
+      return r.fail("Could not find options object in bootstrap config, please add the services manually.");
+    s.insertShorthandPropertyAssignment(0, { name: "services" }), i.addImportDeclaration({
+      namedImports: ["services"],
+      moduleSpecifier: "./services"
+    }), await t.save(i);
+  }
+  getBootstrapOptions(t) {
+    const i = v(t, {
+      guard: d.isCallExpression,
+      validate: (n) => n.getExpression().getText() === "bootstrap",
+      skip: j.ImportDeclaration
+    }), s = i == null ? void 0 : i.getArguments()[1];
+    return d.isObjectLiteralExpression(s) ? s : null;
+  }
+  getServicesObject(t) {
+    const i = v(t, {
+      guard: d.isVariableDeclaration,
+      validate: (n) => n.getName() === "services"
+    }), s = i == null ? void 0 : i.getInitializer();
+    return d.isObjectLiteralExpression(s) ? s : null;
+  }
+}
+a(C, "command", "generate:service"), a(C, "description", "Generate an AerogelJS Service"), a(C, "parameters", [["name", "Service name"]]);
+class B extends g {
+  async run() {
+    r.info("[AerogelJS CLI info]"), r.info("Installation directory: " + x(new S(
+      /* @vite-ignore */
+      "./",
+      import.meta.url
+    )));
+  }
+}
+a(B, "command", "info"), a(B, "description", "Show debugging information about the CLI");
+class U {
+  constructor(e) {
+    a(this, "name");
+    this.name = e;
+  }
+  async install() {
+    this.assertNotInstalled(), await this.beforeInstall(), await this.installDependencies();
+    {
+      const e = q().edit();
+      await this.updateFiles(e), await e.format();
+    }
+    await this.afterInstall(), r.info(`Plugin ${this.name} installed!`);
+  }
+  assertNotInstalled() {
+    c.contains("package.json", `"${this.getNpmPackageName()}"`) && r.fail(`${this.name} is already installed!`);
+  }
+  async beforeInstall() {
+  }
+  async afterInstall() {
+  }
+  async installDependencies() {
+    await r.animate("Installing plugin dependencies", async () => {
+      await this.installNpmDependencies();
+    });
+  }
+  async updateFiles(e) {
+    this.isForDevelopment() || await this.updateBootstrapConfig(e);
+  }
+  async installNpmDependencies() {
+    const e = this.isForDevelopment() ? "--save-dev" : "";
+    if (xe()) {
+      await p.run(`npm install file:${m(this.getLocalPackageName())} ${e}`);
+      return;
+    }
+    if (ke()) {
+      const t = y(this.getLocalPackageName()) ?? h(this.getLocalPackageName());
+      await p.run(`npm install file:${t} ${e}`);
+      return;
+    }
+    await p.run(`npm install ${this.getNpmPackageName()}@next --save-exact ${e}`);
+  }
+  async updateBootstrapConfig(e) {
+    await r.animate("Injecting plugin in bootstrap configuration", async () => {
+      const t = e.requireSourceFile("src/main.ts"), i = this.getBootstrapPluginsDeclaration(t);
+      if (!i)
+        return r.fail(`
+                    Could not find plugins array in bootstrap config, please add the following manually:
+
+                    ${this.getBootstrapConfig()}
+                `);
+      t.addImportDeclaration(this.getBootstrapImport()), i.addElement(this.getBootstrapConfig()), await e.save(t);
+    });
+  }
+  getBootstrapPluginsDeclaration(e) {
+    var l, u;
+    const t = v(e, {
+      guard: d.isCallExpression,
+      validate: (k) => k.getExpression().getText() === "bootstrap",
+      skip: j.ImportDeclaration
+    }), i = t == null ? void 0 : t.getArguments()[1], s = (l = R(i, d.isObjectLiteralExpression)) == null ? void 0 : l.getProperty("plugins"), n = (u = R(s, d.isPropertyAssignment)) == null ? void 0 : u.getInitializer();
+    return d.isArrayLiteralExpression(n) ? n : null;
+  }
+  getTailwindContentArray(e) {
+    const t = v(e, {
+      guard: d.isPropertyAssignment,
+      validate: (s) => s.getName() === "content",
+      skip: j.JSDoc
+    }), i = t == null ? void 0 : t.getInitializer();
+    return d.isArrayLiteralExpression(i) ? i : null;
+  }
+  getBootstrapImport() {
+    return {
+      defaultImport: this.name,
+      moduleSpecifier: `@aerogel/plugin-${this.name}`
+    };
+  }
+  getNpmPackageName() {
+    return `@aerogel/${this.getLocalPackageName()}`;
+  }
+  getLocalPackageName() {
+    return `plugin-${this.name}`;
+  }
+  isForDevelopment() {
+    return !1;
+  }
+  getBootstrapConfig() {
+    return `${this.name}()`;
+  }
+}
+class Se extends U {
+  constructor() {
+    super("solid");
+  }
+  async updateFiles(e) {
+    await this.updateNpmScripts(e), await this.updateGitIgnore(), await super.updateFiles(e);
+  }
+  async installNpmDependencies() {
+    await p.run("npm install soukai-solid@next --save-exact"), await p.run("npm install @noeldemartin/solid-utils@next --save-exact"), await p.run("npm install @solid/community-server@7.1.6 --save-dev -E"), await super.installNpmDependencies();
+  }
+  async updateNpmScripts(e) {
+    r.info("Updating npm scripts...");
+    const t = c.read("package.json");
+    if (!t)
+      return r.fail("Could not find package.json file");
+    c.write(
+      "package.json",
+      t.replace(
+        '"cy:dev": "concurrently --kill-others \\"npm run test:serve-app\\" \\"npm run cy:open\\"",',
+        '"cy:dev": "concurrently --kill-others \\"npm run test:serve-app\\" \\"npm run test:serve-pod\\" \\"npm run cy:open\\"",'
+      ).replace(
+        '"cy:test": "start-server-and-test test:serve-app http-get://localhost:5001 cy:run",',
+        '"cy:test": "start-server-and-test test:serve-app http-get://localhost:5001 test:serve-pod http-get://localhost:3000 cy:run",'
+      ).replace(
+        '"dev": "vite",',
+        `"dev": "vite",
+"dev:serve-pod": "community-solid-server -c @css:config/file.json -f ./solid",`
+      ).replace(
+        '"test:serve-app": "vite --port 5001 --mode testing"',
+        `"test:serve-app": "vite --port 5001 --mode testing",
+"test:serve-pod": "community-solid-server -l warn"`
+      )
+    ), e.addModifiedFile("package.json");
+  }
+  async updateGitIgnore() {
+    r.info("Updating .gitignore");
+    const e = c.read(".gitignore") ?? "";
+    c.write(".gitignore", `${e}/solid
+`);
+  }
+}
+class $e extends U {
+  constructor() {
+    super("soukai");
+  }
+  async installNpmDependencies() {
+    await p.run("npm install soukai@next --save-exact"), await super.installNpmDependencies();
+  }
+  getBootstrapConfig() {
+    return "soukai({ models: import.meta.glob('@/models/*', { eager: true }) })";
+  }
+}
+const V = [new $e(), new Se()].reduce(
+  (o, e) => Object.assign(o, { [e.name]: e }),
+  {}
+);
+class A extends g {
+  constructor(t) {
+    super();
+    a(this, "plugin");
+    this.plugin = V[t] ?? r.fail(`Plugin '${t}' doesn't exist. Available plugins: ${Object.keys(V).join(", ")}`);
+  }
+  async run() {
+    await this.plugin.install();
+  }
+}
+a(A, "command", "install"), a(A, "description", "Install an AerogelJS plugin"), a(A, "parameters", [["plugin", "Plugin to install"]]);
+class be {
+  run(e) {
+    const t = new Z();
+    t.name("gel").description("AerogelJS CLI").version(this.getVersion()), $.define(t), b.define(t), F.define(t), D.define(t), C.define(t), B.define(t), A.define(t), t.parse(e);
+  }
+  getVersion() {
+    const e = "Could not find CLI's version, please report this bug.", t = x(new S(
+      /* @vite-ignore */
+      "../package.json",
+      import.meta.url
+    ));
+    if (!N(t))
+      throw new Error(e);
+    return JSON.parse(z(t).toString()).version ?? ce(e);
+  }
+}
+const Te = L(be);
+export {
+  Te as CLI
+};
+//# sourceMappingURL=aerogel-cli.js.map