silgi 0.19.10 → 0.19.11

package/dist/cli/config/index.mjs

@@ -1,5 +1,4 @@
-export { l as loadOptions } from '../loader.mjs';
-export { s as silgiGenerateType } from '../types.mjs';
+export { l as loadOptions, s as silgiGenerateType } from '../types.mjs';
 import 'c12';
 import 'compatx';
 import 'klona/full';

package/dist/cli/dev.mjs

@@ -5,8 +5,7 @@ import { basename, resolve } from 'pathe';
 import { version } from 'silgi/meta';
 import { silgiCLICtx } from 'silgi/core';
 import { h as hasError } from './compatibility.mjs';
-import { s as scanFiles, b as writeScanFiles, c as createSilgiCLI, p as prepare, w as writeTypesAndFiles, a as writeCoreFile } from './writeTypesAndFiles.mjs';
-import { c as commonArgs } from './common.mjs';
+import { s as scanFiles, w as writeScanFiles, c as commonArgs, a as createSilgiCLI, p as prepare, b as writeTypesAndFiles, d as writeCoreFile } from './common.mjs';
 import 'semver/functions/satisfies.js';
 import 'node:fs';
 import 'node:fs/promises';
@@ -17,6 +16,8 @@ import 'silgi/types';
 import 'unimport';
 import '../_chunks/routeRules.mjs';
 import 'ufo';
+import '@clack/prompts';
+import 'dotenv';
 import 'mlly';
 import 'dev-jiti';
 import 'node:url';
@@ -27,7 +28,7 @@ import 'ignore';
 import '@oxc-parser/wasm';
 import 'klona';
 import 'unstorage';
-import './loader.mjs';
+import './types.mjs';
 import 'c12';
 import 'compatx';
 import 'klona/full';
@@ -37,9 +38,6 @@ import 'escape-string-regexp';
 import 'pkg-types';
 import 'pathe/utils';
 import 'untyped';
-import './types.mjs';
-import '@clack/prompts';
-import 'dotenv';
 
 async function reloadScan(silgi, path, _stats) {
   const startTime = performance.now();

package/dist/cli/index.mjs

@@ -14,9 +14,9 @@ const main = defineCommand({
     }
   },
   subCommands: {
-    prepare: () => import('./prepare.mjs').then((m) => m.default),
+    prepare: () => import('./prepare.mjs').then(function (n) { return n.a; }).then((m) => m.default),
     init: () => import('./init.mjs').then((m) => m.default),
-    run: () => import('./run.mjs').then((m) => m.default),
+    run: () => import('./prepare.mjs').then(function (n) { return n.r; }).then((m) => m.default),
     install: () => import('./install.mjs').then((m) => m.default),
     dev: () => import('./dev.mjs').then((m) => m.default)
   },

package/dist/cli/install.mjs

@@ -5,20 +5,19 @@ import { consola } from 'consola';
 import { resolve } from 'pathe';
 import { version } from 'silgi/meta';
 import { c as commonArgs } from './common.mjs';
-import prepare from './prepare.mjs';
-import { l as loadOptions } from './loader.mjs';
-import '@clack/prompts';
-import 'dotenv';
-import 'silgi/kit';
-import './writeTypesAndFiles.mjs';
+import { p as prepare } from './prepare.mjs';
+import { l as loadOptions } from './types.mjs';
 import 'node:fs/promises';
 import 'hookable';
 import 'silgi/core';
+import 'silgi/kit';
 import 'silgi/runtime/meta';
 import 'silgi/types';
 import 'unimport';
 import '../_chunks/routeRules.mjs';
 import 'ufo';
+import '@clack/prompts';
+import 'dotenv';
 import 'mlly';
 import 'dev-jiti';
 import './compatibility.mjs';
@@ -33,9 +32,6 @@ import 'klona';
 import 'unstorage';
 import 'pathe/utils';
 import 'untyped';
-import './types.mjs';
-import 'pkg-types';
-import './run.mjs';
 import 'picocolors';
 import 'c12';
 import 'compatx';
@@ -43,6 +39,7 @@ import 'klona/full';
 import 'std-env';
 import 'consola/utils';
 import 'escape-string-regexp';
+import 'pkg-types';
 
 const install = defineCommand({
   meta: {

package/dist/cli/prepare.mjs

@@ -1,47 +1,16 @@
 import { defineCommand, runCommand } from 'citty';
-import consola from 'consola';
+import consola$1, { consola } from 'consola';
 import { join, resolve } from 'pathe';
 import { version } from 'silgi/meta';
 import { writeFile } from 'silgi/kit';
-import { c as createSilgiCLI, p as prepare$1, w as writeTypesAndFiles, a as writeCoreFile } from './writeTypesAndFiles.mjs';
-import { c as commonArgs } from './common.mjs';
-import run from './run.mjs';
-import 'node:fs';
-import 'node:fs/promises';
-import 'hookable';
-import 'silgi/core';
-import 'silgi/runtime/meta';
-import 'silgi/types';
-import 'unimport';
-import '../_chunks/routeRules.mjs';
-import 'ufo';
-import 'mlly';
-import 'dev-jiti';
-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 'unstorage';
-import './loader.mjs';
-import 'c12';
-import 'compatx';
-import 'klona/full';
-import 'std-env';
-import 'consola/utils';
-import 'escape-string-regexp';
-import 'pkg-types';
-import 'pathe/utils';
-import 'untyped';
-import './types.mjs';
-import '@clack/prompts';
-import 'dotenv';
-import 'node:child_process';
-import 'picocolors';
+import { c as commonArgs, e as prepareEnv, a as createSilgiCLI, p as prepare$2, b as writeTypesAndFiles, d as writeCoreFile } from './common.mjs';
+import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import * as p from '@clack/prompts';
+import { createJiti } from 'dev-jiti';
+import color from 'picocolors';
+import { silgiCLICtx } from 'silgi/core';
+import { l as loadOptions } from './types.mjs';
 
 function serializeRules(rules, options = {}) {
   try {
@@ -128,6 +97,140 @@ export const routeRules = ${serialized}
   }
 }
 
+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: ["--commands", "run"]
+    }) : void 0;
+    if (data?.result?.silgi) {
+      console.log("Setting silgi context");
+      if (silgiCLICtx.tryUse()) {
+        silgiCLICtx.unset();
+        silgiCLICtx.set(data.result.silgi);
+      } else {
+        silgiCLICtx.set(data.result.silgi);
+        data.result.silgi.hook("close", () => silgiCLICtx.unset());
+      }
+    }
+    const tags = args.tag?.split(",").map((t) => t.trim());
+    p.intro(color.bold(`Silgi CLI ${color.green(`v${version}`)}`));
+    const silgiConfig = await loadOptions({});
+    const getCli = resolve(silgiConfig.build.dir, "cli.json");
+    const cli = readFileSync(getCli, "utf-8");
+    const cliJson = JSON.parse(cli);
+    await prepareEnv(silgiConfig);
+    let selectedCommands = [];
+    if (tags) {
+      for (const commandName of Object.keys(cliJson)) {
+        const scripts = cliJson[commandName];
+        for (const scriptName of Object.keys(scripts)) {
+          const script = scripts[scriptName];
+          if (script.tags && script.tags.some((tag) => tags.includes(tag))) {
+            selectedCommands.push({
+              command: commandName,
+              script: scriptName,
+              handler: script
+            });
+          }
+        }
+      }
+      if (selectedCommands.length === 0) {
+        return;
+      }
+    } else {
+      if (Object.keys(cliJson).length === 0) {
+        consola.warn("No commands found in cli.json");
+        return;
+      }
+      const commandName = await p.select({
+        message: "Select a command to run",
+        options: Object.keys(cliJson).filter((key) => {
+          const scripts2 = cliJson[key];
+          const scriptValues = Object.values(scripts2);
+          return scriptValues;
+        }).map((key) => ({
+          label: key,
+          value: key
+        }))
+      });
+      if (!commandName)
+        return;
+      const scripts = cliJson[commandName];
+      const scriptName = await p.select({
+        message: "Select a script to run",
+        options: Object.keys(scripts).filter((key) => !scripts[key].tags?.length).map((key) => ({
+          label: key,
+          value: key
+        }))
+      });
+      if (!scriptName)
+        return;
+      selectedCommands = [{
+        command: commandName,
+        script: scriptName,
+        handler: scripts[scriptName]
+      }];
+    }
+    for (const cmd of selectedCommands) {
+      consola.info(`Running ${cmd.command}:${cmd.script}...`);
+      if (cmd.handler.enabled === false) {
+        continue;
+      }
+      if (cmd.handler.type === "command") {
+        execSync(cmd.handler.handler, { stdio: "inherit" });
+      }
+      if (cmd.handler.type === "function") {
+        const jiti = createJiti(import.meta.url, {
+          alias: silgiConfig.alias
+        });
+        let cleanHandler = cmd.handler.handler.replace(/\n/g, "");
+        cleanHandler = `import { silgiCLICtx } from 'silgi/core' 
+
+      if (silgiCLICtx.tryUse()) {
+        silgiCLICtx.unset()
+        silgiCLICtx.set(${JSON.stringify(data.result.silgi)})
+      }
+      else {
+        silgiCLICtx.set(${JSON.stringify(data.result.silgi)})
+        data.result.silgi.hook('close', () => silgiCLICtx.unset())
+      }
+        ${cleanHandler}`;
+        await jiti.evalModule(cleanHandler, {
+          filename: import.meta.url,
+          async: true,
+          conditions: silgiConfig.conditions,
+          forceTranspile: true
+        });
+      }
+    }
+  }
+});
+
+const run$1 = {
+  __proto__: null,
+  default: run
+};
+
 const prepare = defineCommand({
   meta: {
     name: "prepare",
@@ -147,9 +250,14 @@ const prepare = defineCommand({
     env: {
       type: "string",
       description: "The environment to use"
+    },
+    commands: {
+      type: "string",
+      description: "The commands to run"
     }
   },
   async run({ args }) {
+    console.log("args", args);
     const rootDir = resolve(args.dir || args._dir || ".");
     const silgi = await createSilgiCLI({
       rootDir,
@@ -159,22 +267,33 @@ const prepare = defineCommand({
       commandType: "prepare",
       activeEnvironment: args.env
     });
-    await prepare$1();
+    await prepare$2();
     await writeTypesAndFiles(silgi);
     await writeCoreFile(silgi);
     await prepareBuild(silgi);
     const close = async () => {
       await silgi.close();
       await silgi.callHook("close", silgi);
-      consola.withTag("silgi").success("Process terminated");
+      consola$1.withTag("silgi").success("Process terminated");
     };
     await silgi.callHook("close", silgi);
-    consola.withTag("silgi").success("Prepare completed");
+    consola$1.withTag("silgi").success("Prepare completed");
     await close();
-    await runCommand(run, {
-      rawArgs: ["--tag", "init"]
-    });
+    if (!args.commands) {
+      await runCommand(run, {
+        rawArgs: ["--tag", "init", "--active", "false"],
+        data: { silgi }
+      });
+    }
+    return {
+      silgi
+    };
   }
 });
 
-export { prepare as default };
+const prepare$1 = {
+  __proto__: null,
+  default: prepare
+};
+
+export { prepare$1 as a, prepare as p, run$1 as r };