silgi 0.24.14 → 0.24.16

package/dist/{cli → chunks}/dev.mjs

@@ -5,10 +5,8 @@ import consola from 'consola';
 import { join } from 'pathe';
 import { useSilgiCLI } from 'silgi';
 import { version } from 'silgi/meta';
-import { s as silgiCLIIClose } from '../_chunks/silgiApp.mjs';
+import { s as silgiCLIIClose } from '../shared/silgi.CvG35CGc.mjs';
 import { c as commonArgs, p as prepare } from './prepare.mjs';
-import 'ufo';
-import 'unctx';
 import 'knitwork';
 import 'silgi/kit';
 import 'node:fs';
@@ -16,11 +14,12 @@ import 'node:fs/promises';
 import 'hookable';
 import 'silgi/runtime/meta';
 import 'unimport';
+import 'ufo';
 import '@clack/prompts';
 import 'dotenv';
 import 'mlly';
 import 'dev-jiti';
-import './compatibility.mjs';
+import '../shared/silgi.DWfN_DdY.mjs';
 import 'semver/functions/satisfies.js';
 import 'node:url';
 import 'defu';
@@ -32,7 +31,7 @@ import '@oxc-parser/wasm';
 import 'klona';
 import 'silgi/runtime';
 import 'unstorage';
-import './types.mjs';
+import '../shared/silgi.BIBmUBIR.mjs';
 import 'c12';
 import 'compatx';
 import 'klona/full';
@@ -41,6 +40,7 @@ import 'consola/utils';
 import 'escape-string-regexp';
 import 'pkg-types';
 import 'pathe/utils';
+import 'unctx';
 import 'node:child_process';
 import 'picocolors';
 

package/dist/{cli → chunks}/install.mjs

@@ -5,7 +5,8 @@ import { consola } from 'consola';
 import { resolve } from 'pathe';
 import { version } from 'silgi/meta';
 import { c as commonArgs, p as prepare } from './prepare.mjs';
-import { l as loadOptions } from './types.mjs';
+import { l as loadOptions } from '../shared/silgi.BIBmUBIR.mjs';
+import '../shared/silgi.CvG35CGc.mjs';
 import 'knitwork';
 import 'silgi/kit';
 import 'node:fs/promises';
@@ -13,14 +14,12 @@ import 'hookable';
 import 'silgi';
 import 'silgi/runtime/meta';
 import 'unimport';
-import '../_chunks/silgiApp.mjs';
 import 'ufo';
-import 'unctx';
 import '@clack/prompts';
 import 'dotenv';
 import 'mlly';
 import 'dev-jiti';
-import './compatibility.mjs';
+import '../shared/silgi.DWfN_DdY.mjs';
 import 'semver/functions/satisfies.js';
 import 'node:url';
 import 'defu';
@@ -33,6 +32,7 @@ import 'klona';
 import 'silgi/runtime';
 import 'unstorage';
 import 'pathe/utils';
+import 'unctx';
 import 'picocolors';
 import 'c12';
 import 'compatx';

package/dist/chunks/prepare.mjs

@@ -0,0 +1,248 @@
+import { defineCommand, runCommand } from 'citty';
+import { resolve } from 'pathe';
+import { version } from 'silgi/meta';
+import { p as prepareEnv, s as silgiCLIIClose, c as createSilgiCLI, a as prepare$2, w as writeTypesAndFiles, b as writeCoreFile, d as prepareBuild } from '../shared/silgi.CvG35CGc.mjs';
+import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import * as p from '@clack/prompts';
+import { consola } from 'consola';
+import { createJiti } from 'dev-jiti';
+import color from 'picocolors';
+import { useSilgiCLI } from 'silgi';
+import { l as loadOptions } from '../shared/silgi.BIBmUBIR.mjs';
+
+const commonArgs = {
+  dir: {
+    type: "string",
+    description: "project root directory"
+  },
+  _dir: {
+    type: "positional",
+    default: ".",
+    description: "project root directory (prefer using `--dir`)"
+  }
+};
+
+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 && args.active) {
+      consola.error("Silgi not found");
+      return;
+    }
+    const silgi = useSilgiCLI();
+    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 (!silgi) {
+        consola.error("Silgi not found");
+        return;
+      }
+      if (Object.keys(cliJson).length === 0) {
+        consola.warn("No commands found in cli.json");
+        return;
+      }
+      const allTags = Object.values(silgi.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 commandName = await p.select({
+        message: "Select a command to run",
+        options: [
+          ...allTags.size ? [{
+            value: "command-tags",
+            label: "Command Tags",
+            hint: "It executes all commands that are related to the tags you select."
+          }] : [],
+          ...Object.keys(cliJson).filter((key) => {
+            const scripts = cliJson[key];
+            const scriptValues = Object.values(scripts);
+            return scriptValues;
+          }).map((key) => ({
+            label: key,
+            value: key
+          }))
+        ]
+      });
+      if (!commandName)
+        return;
+      if (commandName === "command-tags") {
+        const tags2 = Array.from(allTags);
+        const selectedTags = await p.select({
+          message: "Select tags to run",
+          options: tags2.map((tag) => ({
+            label: tag,
+            value: tag
+          }))
+        });
+        if (!selectedTags)
+          return;
+        selectedCommands = Object.keys(cliJson).map(
+          (commandName2) => {
+            const scripts = cliJson[commandName2];
+            return Object.keys(scripts).map((scriptName) => ({
+              command: commandName2,
+              script: scriptName,
+              handler: scripts[scriptName]
+            })).filter((script) => script.handler.tags?.includes(selectedTags));
+          }
+        ).flat();
+      } else {
+        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) {
+      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' 
+        ${cleanHandler}
+`;
+        await jiti.evalModule(cleanHandler, {
+          filename: import.meta.url,
+          async: true,
+          conditions: silgiConfig.conditions,
+          forceTranspile: true
+        });
+      }
+    }
+    await silgiCLIIClose();
+  }
+});
+
+const run$1 = {
+  __proto__: null,
+  default: run
+};
+
+const prepare = defineCommand({
+  meta: {
+    name: "prepare",
+    description: "Generate types for the project",
+    version: version
+  },
+  args: {
+    ...commonArgs,
+    preset: {
+      type: "string",
+      description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
+    },
+    stub: {
+      type: "boolean",
+      description: "Run in silgi development mode"
+    },
+    dev: {
+      type: "boolean",
+      description: "Run in silgi development mode"
+    },
+    env: {
+      type: "string",
+      description: "The environment to use"
+    },
+    commands: {
+      type: "string",
+      description: "The commands to run"
+    }
+  },
+  async run({ args }) {
+    const rootDir = resolve(args.dir || args._dir || ".");
+    const silgi = await createSilgiCLI({
+      rootDir,
+      dev: args.dev || args.stub,
+      stub: args.stub,
+      preset: args.preset,
+      commandType: "prepare",
+      activeEnvironment: args.env
+    });
+    await prepare$2();
+    await writeTypesAndFiles(silgi);
+    await writeCoreFile(silgi);
+    await prepareBuild(silgi);
+    if (!args.commands) {
+      await runCommand(run, {
+        rawArgs: ["--tag", "init", "--active", "false"]
+      });
+    }
+    return {
+      silgi
+    };
+  }
+});
+
+const prepare$1 = {
+  __proto__: null,
+  default: prepare
+};
+
+export { prepare$1 as a, commonArgs as c, prepare as p, run$1 as r };

package/dist/cli/config/index.mjs

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

package/dist/cli/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
 
-const version = "0.24.14";
+const version = "0.24.16";
 const packageJson = {
 	version: version};
 
@@ -18,11 +18,11 @@ 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),
-    install: () => import('./install.mjs').then((m) => m.default),
-    dev: () => import('./dev.mjs').then((m) => m.default)
+    prepare: () => import('../chunks/prepare.mjs').then(function (n) { return n.a; }).then((m) => m.default),
+    init: () => import('../chunks/init.mjs').then((m) => m.default),
+    run: () => import('../chunks/prepare.mjs').then(function (n) { return n.r; }).then((m) => m.default),
+    install: () => import('../chunks/install.mjs').then((m) => m.default),
+    dev: () => import('../chunks/dev.mjs').then((m) => m.default)
   },
   run({ args }) {
     if (args.version)

package/dist/index.d.mts

@@ -1,8 +1,21 @@
-import { SilgiConfig, Silgi, SilgiEvents, SilgiFunction, SilgiOperation, MergedSilgiSchema, ServiceType, SilgiSchema, RequiredServiceType, SilgiRuntimeSharedsExtend, SilgiRuntimeContext, DefaultNamespaces, BaseSchemaType, SilgiRuntimeShareds, StorageConfig, SilgiCLI, SilgiStorageBase } from 'silgi/types';
+import { SilgiCLI, SilgiCLIConfig, LoadConfigOptions, SilgiConfig, Silgi, SilgiEvents, SilgiFunction, SilgiOperation, MergedSilgiSchema, ServiceType, SilgiSchema, RequiredServiceType, SilgiRuntimeSharedsExtend, SilgiRuntimeContext, DefaultNamespaces, BaseSchemaType, SilgiRuntimeShareds, StorageConfig, SilgiStorageBase } from 'silgi/types';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { Storage, StorageValue } from 'unstorage';
 import * as unctx from 'unctx';
 
+/**
+ * Prepares route rules for the build
+ */
+declare function prepareBuild(silgi: SilgiCLI): Promise<void>;
+
+declare function prepare(_silgi: SilgiCLI): Promise<void>;
+
+declare function createSilgiCLI(config?: SilgiCLIConfig, opts?: LoadConfigOptions): Promise<SilgiCLI>;
+
+declare function writeCoreFile(silgi: SilgiCLI): Promise<void>;
+
+declare function writeTypesAndFiles(silgi: SilgiCLI): Promise<void>;
+
 declare function createSilgi(config: SilgiConfig): Promise<Silgi>;
 
 declare function silgi(event?: SilgiEvents | Record<string, any>): SilgiFunction;
@@ -267,5 +280,5 @@ declare function storageMount<T extends Storage = Storage>(silgi?: Silgi): (base
 
 declare const autoImportTypes: string[];
 
-export { ErrorCategory, ErrorFactory, ErrorSeverity, HttpStatus, SilgiError, autoImportTypes, createSchema, createService, createShared, createSilgi, createStorage, getEvent, getEventContext, isBaseError, mergeSchemas, mergeServices, mergeShared, parseURI, replaceRuntimeValues, silgi, silgiCLICtx, silgiCtx, storageMount, tryUseSilgi, tryUseSilgiCLI, useSilgi, useSilgiCLI, useSilgiStorage };
+export { ErrorCategory, ErrorFactory, ErrorSeverity, HttpStatus, SilgiError, autoImportTypes, createSchema, createService, createShared, createSilgi, createSilgiCLI, createStorage, getEvent, getEventContext, isBaseError, mergeSchemas, mergeServices, mergeShared, parseURI, prepare, prepareBuild, replaceRuntimeValues, silgi, silgiCLICtx, silgiCtx, storageMount, tryUseSilgi, tryUseSilgiCLI, useSilgi, useSilgiCLI, useSilgiStorage, writeCoreFile, writeTypesAndFiles };
 export type { BaseError, ErrorMetadata };

package/dist/index.mjs

@@ -1,14 +1,44 @@
+import { e as createRouteRules } from './shared/silgi.CvG35CGc.mjs';
+export { c as createSilgiCLI, a as prepare, d as prepareBuild, f as silgiCLICtx, t as tryUseSilgiCLI, u as useSilgiCLI, b as writeCoreFile, w as writeTypesAndFiles } from './shared/silgi.CvG35CGc.mjs';
 import { createConsola } from 'consola';
 import defu, { defu as defu$1 } from 'defu';
 import { createHooks } from 'hookable';
-import { c as createRouteRules } from './_chunks/silgiApp.mjs';
-export { a as silgiCLICtx, t as tryUseSilgiCLI, u as useSilgiCLI } from './_chunks/silgiApp.mjs';
 import { getContext } from 'unctx';
 import { Buffer } from 'node:buffer';
 import { klona } from 'klona';
 import { useSilgiRuntimeConfig } from 'silgi/runtime';
 import { createStorage as createStorage$1, builtinDrivers, prefixStorage } from 'unstorage';
+import 'knitwork';
+import 'pathe';
+import 'silgi/kit';
+import 'node:fs';
+import 'node:fs/promises';
+import 'silgi';
+import 'silgi/runtime/meta';
+import 'unimport';
 import 'ufo';
+import '@clack/prompts';
+import 'dotenv';
+import 'mlly';
+import 'dev-jiti';
+import './shared/silgi.DWfN_DdY.mjs';
+import 'semver/functions/satisfies.js';
+import 'silgi/meta';
+import 'node:url';
+import 'exsolve';
+import 'untyped';
+import 'globby';
+import 'ignore';
+import '@oxc-parser/wasm';
+import './shared/silgi.BIBmUBIR.mjs';
+import 'c12';
+import 'compatx';
+import 'klona/full';
+import 'std-env';
+import 'consola/utils';
+import 'escape-string-regexp';
+import 'pkg-types';
+import 'pathe/utils';
 
 const silgiCtx = getContext("silgi");
 function useSilgi() {

package/dist/kit/index.d.mts

@@ -1,34 +1,17 @@
+import { ConsolaOptions, ConsolaInstance } from 'consola';
 import { SilgiCLI, ModuleOptionsCustom, ModuleDefinition, SilgiModule, ServiceParseModule, SilgiPreset, SilgiPresetMeta, SilgiTemplate, ResolvedSilgiTemplate, SilgiEvents } from 'silgi/types';
 import { Buffer } from 'node:buffer';
-import * as consola from 'consola';
-import { ConsolaOptions } from 'consola';
 import { IncomingMessage, ServerResponse } from 'node:http';
 
-declare function hasError(type: SilgiCLI['errors'][0]['type'], silgi?: SilgiCLI): boolean;
+declare function useLogger(tag?: string, options?: Partial<ConsolaOptions>): ConsolaInstance;
 
-declare function directoryToURL(dir: string): URL;
-/**
- * Resolve a module from a given root path using an algorithm patterned on
- * the upcoming `import.meta.resolve`. It returns a file URL
- *
- * @internal
- */
-declare function tryResolveModule(id: string, url?: string | string[]): Promise<string | undefined>;
+declare function hasError(type: SilgiCLI['errors'][0]['type'], silgi?: SilgiCLI): boolean;
 
 declare function writeFile(file: string, contents: Buffer | string, log?: boolean): Promise<void>;
 declare function isDirectory(path: string): Promise<boolean>;
 
-declare function genEnsureSafeVar(name: string | any): string;
-declare function getAllEntries(obj: object): [string, any][];
-
 declare function hash(data: any): string;
 
-declare function isNuxt(): boolean;
-declare function isNitro(): boolean;
-declare function isH3(): boolean;
-
-declare function useLogger(tag?: string, options?: Partial<ConsolaOptions>): consola.ConsolaInstance;
-
 /**
  * Define a Silgi module, automatically merging defaults with user provided options, installing
  * any hooks that are provided, and calling an optional setup function for full control.
@@ -127,6 +110,22 @@ declare function getIpAddress(event: SilgiEvents): string | false;
  */
 declare function ipAddress(req: IncomingMessage): string;
 
+declare function directoryToURL(dir: string): URL;
+/**
+ * Resolve a module from a given root path using an algorithm patterned on
+ * the upcoming `import.meta.resolve`. It returns a file URL
+ *
+ * @internal
+ */
+declare function tryResolveModule(id: string, url?: string | string[]): Promise<string | undefined>;
+
+declare function genEnsureSafeVar(name: string | any): string;
+declare function getAllEntries(obj: object): [string, any][];
+
+declare function isNuxt(): boolean;
+declare function isNitro(): boolean;
+declare function isH3(): boolean;
+
 declare function relativeWithDot(from: string, to: string): string;
 /** @since 3.9.0 */
 declare function toArray<T>(value: T | T[]): T[];