silgi 0.29.6 → 0.29.7

package/dist/cli/dev.mjs

@@ -45,7 +45,6 @@ import 'klona';
 import 'silgi/runtime';
 import 'unstorage';
 import 'scule';
-import 'node:child_process';
 
 async function reloadScan(path, _stats) {
   const silgi = useSilgiCLI();

package/dist/cli/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
 
-const version = "0.29.6";
+const version = "0.29.7";
 const packageJson = {
 	version: version};
 
@@ -20,7 +20,7 @@ const main = defineCommand({
   subCommands: {
     prepare: () => import('./prepare.mjs').then(function (n) { return n.a; }).then((m) => m.default),
     init: () => import('./init.mjs').then((m) => m.default),
-    run: () => import('./prepare.mjs').then(function (n) { return n.r; }).then((m) => m.default),
+    run: () => import('./run.mjs').then((m) => m.default),
     install: () => import('./install.mjs').then((m) => m.default),
     dev: () => import('./dev.mjs').then((m) => m.default)
   },

package/dist/cli/init.mjs

@@ -41,9 +41,6 @@ import 'klona';
 import 'silgi/runtime';
 import 'unstorage';
 import 'scule';
-import 'node:child_process';
-import '../_chunks/silgiApp.mjs';
-import 'unctx';
 
 const init = defineCommand({
   meta: {

package/dist/cli/prepare.mjs

@@ -1,17 +1,7 @@
-import { defineCommand, runCommand } from 'citty';
+import { defineCommand } from 'citty';
 import { resolve } from 'pathe';
 import { version } from 'silgi/meta';
-import { p as prepareEnv, c as createSilgiCLI, b as build } from './silgi.mjs';
-import { execSync } from 'node:child_process';
-import * as p from '@clack/prompts';
-import { isCancel, cancel } from '@clack/prompts';
-import { consola } from 'consola';
-import { createJiti } from 'dev-jiti';
-import { useSilgiCLI as useSilgiCLI$1 } from 'silgi';
-import { u as useSilgiCLI, a as silgiCLIIClose } from '../_chunks/silgiApp.mjs';
-import { addTemplate } from 'silgi/kit';
-import { generateTypes, resolveSchema } from 'untyped';
-import { l as loadOptions } from './types.mjs';
+import { c as createSilgiCLI, b as build } from './silgi.mjs';
 
 const commonArgs = {
   dir: {
@@ -25,171 +15,6 @@ const commonArgs = {
   }
 };
 
-function debugMode(name) {
-  const silgi = useSilgiCLI();
-  if (silgi.options.debug === true || typeof silgi.options.debug === "object" && silgi.options.debug[name]) {
-    return true;
-  }
-  return false;
-}
-
-async function scanCommands(silgi = useSilgiCLI()) {
-  const commands = [];
-  await silgi.callHook("prepare:commands", commands);
-  if (debugMode("command")) {
-    addTemplate({
-      filename: "cli.json",
-      where: ".silgi",
-      write: true,
-      getContents: () => JSON.stringify(commands, null, 2)
-    });
-  }
-  silgi.hook("prepare:schema.ts", async (object) => {
-    const allTags = commands.reduce((acc, commandGroup) => {
-      Object.values(commandGroup).forEach((command) => {
-        if (command.tags) {
-          command.tags.forEach((tag) => acc.add(tag));
-        }
-      });
-      return acc;
-    }, /* @__PURE__ */ new Set());
-    const data = [
-      "",
-      generateTypes(
-        await resolveSchema(
-          {
-            ...Object.fromEntries(Array.from(allTags.values()).map((tag) => [tag, "string"]))
-          }
-        ),
-        {
-          interfaceName: "SilgiCommandsExtended",
-          addExport: false,
-          addDefaults: false,
-          allowExtraKeys: false,
-          indentation: 0
-        }
-      ),
-      ""
-    ];
-    object.customImports?.push(...data);
-  });
-  return commands;
-}
-
-function cancelOnCancel({
-  value,
-  message = "Cancelled",
-  onBeforeExit,
-  exitCode = 0
-} = {}) {
-  const handleCancel = () => {
-    cancel(message);
-    onBeforeExit?.();
-    process.exit(exitCode);
-  };
-  if (!value || isCancel(value))
-    handleCancel();
-}
-
-const run = defineCommand({
-  meta: {
-    name: "run",
-    description: "Run a command from the CLI",
-    version: version
-  },
-  args: {
-    ...commonArgs,
-    preset: {
-      type: "string",
-      description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
-    },
-    tag: {
-      type: "string"
-    },
-    active: {
-      type: "boolean",
-      description: "Run in silgi development mode",
-      default: true
-    }
-  },
-  async run({ args }) {
-    const data = args.active ? await runCommand(prepare, {
-      rawArgs: ["--commandType", "run"]
-    }) : void 0;
-    const silgi = useSilgiCLI$1();
-    const commands = await scanCommands();
-    globalThis.__nitro__ = globalThis.__nitro__ || {};
-    globalThis.__nitro__.useRuntimeConfig = function() {
-      return data?.result?.silgi?.options?.runtimeConfig || {};
-    };
-    if (!data?.result?.silgi && args.active) {
-      consola.error("Silgi not found");
-      return;
-    }
-    const tags = args.tag?.split(",").map((t) => t.trim());
-    const silgiConfig = await loadOptions({});
-    await prepareEnv(silgiConfig);
-    let selectedCommands = [];
-    if (tags?.length) {
-      selectedCommands = commands.filter((cmd) => cmd.tags?.some((tag) => tags.includes(tag))).filter((cmd) => cmd.when !== false);
-    } else {
-      selectedCommands = commands.filter((cmd) => cmd.when !== false);
-    }
-    const multiSelect = await p.groupMultiselect({
-      message: "Select commands to run",
-      required: true,
-      options: {
-        ...selectedCommands.sort((a, b) => (a.order || Infinity) - (b.order || Infinity)).reduce((acc, cmd) => {
-          if (!acc[cmd.group || ""]) {
-            acc[cmd.group || ""] = [];
-          }
-          acc[cmd.group || ""].push({
-            label: cmd.name,
-            value: cmd,
-            hint: cmd.description
-          });
-          return acc;
-        }, {})
-      }
-    });
-    cancelOnCancel({ value: multiSelect });
-    selectedCommands = multiSelect;
-    const spinner = p.spinner({
-      indicator: "dots"
-    });
-    for (const cmd of selectedCommands) {
-      const data2 = cmd.getContents({ app: silgi });
-      spinner.start(`[${cmd.group}] ${cmd.name}...`);
-      if (cmd.type === "command") {
-        execSync(data2, { stdio: "inherit" });
-      }
-      if (cmd.type === "function") {
-        const jiti = createJiti(import.meta.url, {
-          alias: silgiConfig.alias
-        });
-        let cleanHandler = cmd.getContents({ app: silgi }).replace(/\n/g, "");
-        cleanHandler = `import { silgiCLICtx } from 'silgi' 
-        ${cleanHandler}
-`;
-        await jiti.evalModule(cleanHandler, {
-          filename: import.meta.url,
-          async: true,
-          conditions: silgiConfig.conditions,
-          forceTranspile: true
-        });
-      }
-      spinner.stop();
-      consola.success(`[${cmd.group}] ${cmd.name} done`);
-    }
-    await silgiCLIIClose();
-  }
-});
-
-const run$1 = {
-  __proto__: null,
-  default: run
-};
-
 const prepare = defineCommand({
   meta: {
     name: "prepare",
@@ -230,14 +55,6 @@ const prepare = defineCommand({
       activeEnvironment: args.env
     });
     await build(silgi);
-    if (args.commandType !== "run") {
-      await runCommand(run, {
-        rawArgs: ["--tag", "init", "--active", "false"]
-      });
-    }
-    return {
-      silgi
-    };
   }
 });
 
@@ -246,4 +63,4 @@ const prepare$1 = {
   default: prepare
 };
 
-export { prepare$1 as a, commonArgs as c, prepare as p, run$1 as r };
+export { prepare$1 as a, commonArgs as c, prepare as p };

package/dist/cli/run.mjs

@@ -0,0 +1,209 @@
+import { execSync } from 'node:child_process';
+import * as p from '@clack/prompts';
+import { isCancel, cancel } from '@clack/prompts';
+import { defineCommand, runCommand } from 'citty';
+import { consola } from 'consola';
+import { createJiti } from 'dev-jiti';
+import { useSilgiCLI as useSilgiCLI$1 } from 'silgi';
+import { version } from 'silgi/meta';
+import { u as useSilgiCLI, a as silgiCLIIClose } from '../_chunks/silgiApp.mjs';
+import { addTemplate } from 'silgi/kit';
+import { generateTypes, resolveSchema } from 'untyped';
+import { c as commonArgs, p as prepare } from './prepare.mjs';
+import { p as prepareEnv } from './silgi.mjs';
+import { l as loadOptions } from './types.mjs';
+import 'unctx';
+import 'pathe';
+import 'apiful/openapi';
+import 'node:fs';
+import 'node:fs/promises';
+import 'knitwork';
+import 'mlly';
+import 'pathe/utils';
+import 'silgi/runtime/meta';
+import 'unimport';
+import 'hookable';
+import '../_chunks/routeRules.mjs';
+import 'ufo';
+import 'dotenv';
+import './compatibility.mjs';
+import 'semver/functions/satisfies.js';
+import 'node:url';
+import 'defu';
+import 'exsolve';
+import 'globby';
+import 'ignore';
+import '@oxc-parser/wasm';
+import 'klona';
+import 'silgi/runtime';
+import 'unstorage';
+import 'scule';
+import 'c12';
+import 'compatx';
+import 'klona/full';
+import 'std-env';
+import 'consola/utils';
+import 'escape-string-regexp';
+import 'pkg-types';
+
+function debugMode(name) {
+  const silgi = useSilgiCLI();
+  if (silgi.options.debug === true || typeof silgi.options.debug === "object" && silgi.options.debug[name]) {
+    return true;
+  }
+  return false;
+}
+
+async function scanCommands(silgi = useSilgiCLI()) {
+  const commands = [];
+  await silgi.callHook("prepare:commands", commands);
+  if (debugMode("command")) {
+    addTemplate({
+      filename: "cli.json",
+      where: ".silgi",
+      write: true,
+      getContents: () => JSON.stringify(commands, null, 2)
+    });
+  }
+  silgi.hook("prepare:schema.ts", async (object) => {
+    const allTags = commands.reduce((acc, commandGroup) => {
+      Object.values(commandGroup).forEach((command) => {
+        if (command.tags) {
+          command.tags.forEach((tag) => acc.add(tag));
+        }
+      });
+      return acc;
+    }, /* @__PURE__ */ new Set());
+    const data = [
+      "",
+      generateTypes(
+        await resolveSchema(
+          {
+            ...Object.fromEntries(Array.from(allTags.values()).map((tag) => [tag, "string"]))
+          }
+        ),
+        {
+          interfaceName: "SilgiCommandsExtended",
+          addExport: false,
+          addDefaults: false,
+          allowExtraKeys: false,
+          indentation: 0
+        }
+      ),
+      ""
+    ];
+    object.customImports?.push(...data);
+  });
+  return commands;
+}
+
+function cancelOnCancel({
+  value,
+  message = "Cancelled",
+  onBeforeExit,
+  exitCode = 0
+} = {}) {
+  const handleCancel = () => {
+    cancel(message);
+    onBeforeExit?.();
+    process.exit(exitCode);
+  };
+  if (!value || isCancel(value))
+    handleCancel();
+}
+
+const run = defineCommand({
+  meta: {
+    name: "run",
+    description: "Run a command from the CLI",
+    version: version
+  },
+  args: {
+    ...commonArgs,
+    preset: {
+      type: "string",
+      description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
+    },
+    tag: {
+      type: "string"
+    },
+    active: {
+      type: "boolean",
+      description: "Run in silgi development mode",
+      default: true
+    }
+  },
+  async run({ args }) {
+    const data = args.active ? await runCommand(prepare, {
+      rawArgs: ["--commandType", "run"]
+    }) : void 0;
+    const silgi = useSilgiCLI$1();
+    const commands = await scanCommands();
+    globalThis.__nitro__ = globalThis.__nitro__ || {};
+    globalThis.__nitro__.useRuntimeConfig = function() {
+      return data?.result?.silgi?.options?.runtimeConfig || {};
+    };
+    if (!data?.result?.silgi && args.active) {
+      consola.error("Silgi not found");
+      return;
+    }
+    const tags = args.tag?.split(",").map((t) => t.trim());
+    const silgiConfig = await loadOptions({});
+    await prepareEnv(silgiConfig);
+    let selectedCommands = [];
+    if (tags?.length) {
+      selectedCommands = commands.filter((cmd) => cmd.tags?.some((tag) => tags.includes(tag))).filter((cmd) => cmd.when !== false);
+    } else {
+      selectedCommands = commands.filter((cmd) => cmd.when !== false);
+    }
+    const multiSelect = await p.groupMultiselect({
+      message: "Select commands to run",
+      required: true,
+      options: {
+        ...selectedCommands.sort((a, b) => (a.order || Infinity) - (b.order || Infinity)).reduce((acc, cmd) => {
+          if (!acc[cmd.group || ""]) {
+            acc[cmd.group || ""] = [];
+          }
+          acc[cmd.group || ""].push({
+            label: cmd.name,
+            value: cmd,
+            hint: cmd.description
+          });
+          return acc;
+        }, {})
+      }
+    });
+    cancelOnCancel({ value: multiSelect });
+    selectedCommands = multiSelect;
+    const spinner = p.spinner({
+      indicator: "dots"
+    });
+    for (const cmd of selectedCommands) {
+      const data2 = cmd.getContents({ app: silgi });
+      spinner.start(`[${cmd.group}] ${cmd.name}...`);
+      if (cmd.type === "command") {
+        execSync(data2, { stdio: "inherit" });
+      }
+      if (cmd.type === "function") {
+        const jiti = createJiti(import.meta.url, {
+          alias: silgiConfig.alias
+        });
+        let cleanHandler = cmd.getContents({ app: silgi }).replace(/\n/g, "");
+        cleanHandler = `import { silgiCLICtx } from 'silgi' 
+        ${cleanHandler}
+`;
+        await jiti.evalModule(cleanHandler, {
+          filename: import.meta.url,
+          async: true,
+          conditions: silgiConfig.conditions,
+          forceTranspile: true
+        });
+      }
+      spinner.stop();
+      consola.success(`[${cmd.group}] ${cmd.name} done`);
+    }
+    await silgiCLIIClose();
+  }
+});
+
+export { run as default };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.29.6",
+  "version": "0.29.7",
   "private": false,
   "sideEffects": false,
   "exports": {