silgi 0.42.4 → 0.43.0

package/dist/cli/prepare.mjs

@@ -1,188 +0,0 @@
-import { defineCommand, runCommand } from 'citty';
-import { resolve } from 'pathe';
-import { readPackageJSON } from 'pkg-types';
-import { version } from 'silgi/meta';
-import { p as prepareEnv, c as createSilgiCLI, b as build } from './build.mjs';
-import { c as commonArgs } from './common.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 } from 'silgi';
-import { a as silgiCLIIClose } from '../_chunks/silgiApp.mjs';
-import { l as loadOptions } from './loader.mjs';
-
-function cancelOnCancel({
-  value,
-  message = "Cancelled",
-  onBeforeExit,
-  exitCode = 0
-} = {}) {
-  const handleCancel = () => {
-    cancel(message);
-    onBeforeExit?.();
-    process.exit(exitCode);
-  };
-  if (!value || isCancel(value))
-    handleCancel();
-}
-
-const command$1 = 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"
-    },
-    prepare: {
-      type: "boolean",
-      description: "Run in silgi development mode",
-      default: true
-    }
-  },
-  async run({ args }) {
-    if (args.prepare) {
-      await runCommand(command, {
-        rawArgs: ["--commandType", "commands"]
-      });
-    }
-    const silgi = useSilgiCLI();
-    if (!silgi) {
-      throw new Error("Silgi is not initialized");
-    }
-    const commands = silgi.options.commands;
-    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);
-    }
-    if (!selectedCommands.length) {
-      return;
-    }
-    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 data = cmd.getContents({ app: silgi });
-      spinner.start(`[${cmd.group}] ${cmd.name}...`);
-      if (cmd.type === "command") {
-        execSync(data, { 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 commands = {
-  __proto__: null,
-  default: command$1
-};
-
-const command = 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"
-    },
-    commandType: {
-      type: "string",
-      description: "The command type to run"
-    }
-  },
-  async run({ args }) {
-    const rootDir = resolve(args.dir || args._dir || ".");
-    const packageJson = await readPackageJSON(rootDir);
-    const packageName = packageJson.name || "";
-    const silgi = await createSilgiCLI({
-      rootDir,
-      dev: args.dev || args.stub,
-      stub: args.stub,
-      preset: args.preset,
-      commandType: args.commandType || "prepare",
-      activeEnvironment: args.env,
-      package: {
-        name: packageName
-      }
-    });
-    await build(silgi);
-    if (args.commandType !== "commands") {
-      await runCommand(command$1, {
-        rawArgs: ["--tag", "init", "--prepare", "false"]
-      });
-    }
-  }
-});
-
-const prepare = {
-  __proto__: null,
-  default: command
-};
-
-export { command as a, commands as b, cancelOnCancel as c, prepare as p };

package/dist/cli/reset.mjs

@@ -1,55 +0,0 @@
-import fsp from 'node:fs/promises';
-import { defineCommand } from 'citty';
-import consola from 'consola';
-import { resolve, join } from 'pathe';
-import { version } from 'silgi/meta';
-import { l as loadOptions } from './loader.mjs';
-import { c as commonArgs } from './common.mjs';
-import 'c12';
-import 'compatx';
-import 'klona/full';
-import 'std-env';
-import 'consola/utils';
-import 'escape-string-regexp';
-import 'mlly';
-import 'node:fs';
-import 'pkg-types';
-import 'silgi/kit';
-import 'silgi/runtime/meta';
-import 'ufo';
-
-const command = defineCommand({
-  meta: {
-    name: "prepare",
-    description: "Generate types for the project",
-    version: version
-  },
-  args: {
-    ...commonArgs
-  },
-  async run({ args }) {
-    const rootDir = resolve(args.dir || args._dir || ".");
-    const options = await loadOptions({
-      rootDir
-    }, {});
-    const serverDir = options.silgi.serverDir;
-    const vfs = join(serverDir, "vfs");
-    const configs = join(serverDir, "configs.ts");
-    const core = join(serverDir, "core.ts");
-    const scan = join(serverDir, "scan.ts");
-    const meta = join(serverDir, "meta.ts");
-    const silgiDir = options.build.dir;
-    for (const file of [vfs, configs, core, scan, silgiDir, meta]) {
-      try {
-        await fsp.rm(file, {
-          force: true,
-          recursive: true
-        });
-        consola.success(`Removed ${file.replace(rootDir, "")}`);
-      } catch {
-      }
-    }
-  }
-});
-
-export { command as default };

package/dist/cli/run.mjs

@@ -1,159 +0,0 @@
-import { defineCommand, runCommand } from 'citty';
-import consola from 'consola';
-import { useSilgiCLI } from 'silgi';
-import { version } from 'silgi/meta';
-import { x } from 'tinyexec';
-import { w as watchDev } from './dev.mjs';
-import { c as commonArgs } from './common.mjs';
-import { a as command$1 } from './prepare.mjs';
-import 'chokidar';
-import 'pathe';
-import 'perfect-debounce';
-import '../_chunks/silgiApp.mjs';
-import 'unctx';
-import './build.mjs';
-import 'hookable';
-import 'silgi/kit';
-import 'silgi/runtime';
-import 'silgi/runtime/meta';
-import 'unimport';
-import '@clack/prompts';
-import 'node:fs';
-import 'dotenv';
-import 'knitwork';
-import 'node:path';
-import 'mlly';
-import 'dev-jiti';
-import './compatibility.mjs';
-import 'semver/functions/satisfies.js';
-import 'node:url';
-import 'defu';
-import 'exsolve';
-import 'ufo';
-import 'node:fs/promises';
-import 'micromatch';
-import 'oxc-parser';
-import 'tinyglobby';
-import 'ignore';
-import 'scule';
-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 'apiful/openapi';
-import 'pathe/utils';
-import 'untyped';
-import './types.mjs';
-import 'node:child_process';
-
-const command = defineCommand({
-  meta: {
-    name: "dev",
-    description: "Start the development server for the project",
-    version: version
-  },
-  args: {
-    ...commonArgs,
-    command: {
-      type: "string",
-      description: "your application start command",
-      required: false
-    }
-  },
-  async run({ args, rawArgs }) {
-    await runCommand(command$1, {
-      rawArgs: ["--commandType", "dev", "--dev", "true"]
-    });
-    const silgi = useSilgiCLI();
-    const startCommand = args.command || rawArgs[0];
-    let childPid = null;
-    let hasExited = false;
-    let exitTimeout = null;
-    const cleanupAndExit = (code = 0) => {
-      if (hasExited)
-        return;
-      hasExited = true;
-      if (exitTimeout)
-        clearTimeout(exitTimeout);
-      process.exit(code);
-    };
-    const handleSignal = async (signal, watcher) => {
-      consola.info(`Received ${signal}, terminating process...`);
-      if (watcher && typeof watcher.close === "function") {
-        try {
-          await watcher.close();
-        } catch {
-        }
-      }
-      if (childPid) {
-        try {
-          process.kill(childPid, signal);
-        } catch (err) {
-          consola.error(`Failed to kill process: ${err instanceof Error ? err.message : err}`);
-        }
-        exitTimeout = setTimeout(() => {
-          consola.warn("Process did not exit gracefully, forcing termination...");
-          try {
-            if (childPid)
-              process.kill(childPid, "SIGKILL");
-          } catch {
-          }
-          cleanupAndExit(1);
-        }, 3e3);
-      } else {
-        cleanupAndExit(0);
-      }
-    };
-    const setupSignalHandlers = (watcher) => {
-      ["SIGINT", "SIGTERM", "SIGHUP"].forEach((signal) => {
-        process.on(signal, () => {
-          handleSignal(signal, watcher);
-        });
-      });
-    };
-    try {
-      const watcher = await watchDev();
-      setupSignalHandlers(watcher);
-      consola.info(`Starting command: nr ${startCommand}`);
-      const proc = x(
-        "nr",
-        [startCommand],
-        {
-          nodeOptions: {
-            stdio: "inherit",
-            shell: true,
-            cwd: process.cwd(),
-            killSignal: "SIGINT"
-          }
-        }
-      );
-      if (proc && typeof proc.pid === "number") {
-        childPid = proc.pid;
-      }
-      try {
-        await proc;
-        consola.success(`Process exited successfully.`);
-        cleanupAndExit(0);
-      } catch (procError) {
-        const exitCode = procError && typeof procError.exitCode === "number" ? procError.exitCode : 1;
-        consola.error(`Process exited with code: ${exitCode}`);
-        if (silgi.options.debug)
-          consola.withTag("silgi").error("Error while running the command", procError);
-        cleanupAndExit(exitCode);
-      }
-    } catch (error) {
-      consola.error(`Failed to start the development server: ${error instanceof Error ? error.message : error}`);
-      if (silgi.options.debug)
-        consola.withTag("silgi").error("Error while running the command", error);
-      cleanupAndExit(1);
-    }
-  }
-});
-
-export { command as default };

package/dist/cli/types.mjs

@@ -1,233 +0,0 @@
-import { promises, lstatSync } from 'node:fs';
-import { defu } from 'defu';
-import { resolve, dirname, join, isAbsolute, relative } from 'pathe';
-import { readPackageJSON } from 'pkg-types';
-import { relativeWithDot, resolveSilgiModule, isPresents } from 'silgi/kit';
-import { withTrailingSlash } from 'ufo';
-
-function getDirectory(p) {
-  try {
-    return isAbsolute(p) && lstatSync(p).isFile() ? dirname(p) : p;
-  } catch {
-  }
-  return p;
-}
-function renderAttrs(obj) {
-  const attrs = [];
-  for (const key in obj) {
-    attrs.push(renderAttr(key, obj[key]));
-  }
-  return attrs.join(" ");
-}
-function renderAttr(key, value) {
-  return value ? `${key}="${value}"` : "";
-}
-async function silgiGenerateType(silgi) {
-  const rootDirWithSlash = withTrailingSlash(silgi.options.rootDir);
-  const tsConfigPath = resolve(
-    silgi.options.rootDir,
-    silgi.options.typescript.tsconfigPath
-  );
-  const tsconfigDir = dirname(tsConfigPath);
-  const include = /* @__PURE__ */ new Set([
-    relativeWithDot(tsconfigDir, join(silgi.options.build.typesDir, "silgi-config.d.ts")).replace(
-      /^(?=[^.])/,
-      "./"
-    ),
-    join(relativeWithDot(tsconfigDir, silgi.options.rootDir), "**/*"),
-    ...silgi.options.srcDir === silgi.options.rootDir ? [] : [join(relativeWithDot(tsconfigDir, silgi.options.srcDir), "**/*")]
-  ]);
-  const exclude = /* @__PURE__ */ new Set([
-    // nitro generate output: https://github.com/nuxt/nuxt/blob/main/packages/nuxt/src/core/nitro.ts#L186
-    relativeWithDot(tsconfigDir, "node_modules"),
-    relativeWithDot(tsconfigDir, "dist")
-  ]);
-  for (const dir of silgi.options.modulesDir) {
-    exclude.add(relativeWithDot(silgi.options.build.dir, dir));
-  }
-  const moduleEntryPaths = [];
-  for (const m of silgi.scanModules) {
-    if (m.entryPath) {
-      moduleEntryPaths.push(getDirectory(m.entryPath));
-    }
-  }
-  const modulePaths = await resolveSilgiModule(rootDirWithSlash, moduleEntryPaths);
-  for (const path of modulePaths) {
-    const relative2 = relativeWithDot(tsconfigDir, path);
-    include.add(join(relative2, "runtime"));
-    exclude.add(join(relative2, "runtime/server"));
-    include.add(join(relative2, "dist/runtime"));
-    exclude.add(join(relative2, "dist/runtime/server"));
-  }
-  let tsConfig = silgi.options.typescript?.tsConfig || {};
-  const defaultConfig = defu(tsConfig, {
-    compilerOptions: {
-      /* Base options: */
-      esModuleInterop: true,
-      allowSyntheticDefaultImports: true,
-      skipLibCheck: true,
-      allowImportingTsExtensions: true,
-      baseUrl: "./",
-      /* Target options: */
-      target: "ESNext",
-      allowJs: true,
-      resolveJsonModule: true,
-      moduleDetection: "force",
-      isolatedModules: true,
-      verbatimModuleSyntax: true,
-      strict: true,
-      noUncheckedIndexedAccess: true,
-      noImplicitOverride: true,
-      forceConsistentCasingInFileNames: true,
-      noEmit: true,
-      /* If NOT transpiling with TypeScript: */
-      module: "Preserve",
-      moduleResolution: "bundler",
-      useDefineForClassFields: true,
-      noImplicitThis: true,
-      jsx: "preserve",
-      customConditions: silgi.options.typescript.customConditions,
-      paths: {
-        // '#silgiImports': [
-        //   relativeWithDot(tsconfigDir, join(silgi.options.build.typesDir, 'silgi-imports')),
-        // ],
-        // ...(silgi.scanModules.reduce((acc: Record<string, string[]>, m) => {
-        //   if (m.entryPath) {
-        //     acc[m.meta.name!] = [relativeWithDot(tsconfigDir, m.entryPath)]
-        //   }
-        //   return acc
-        // }, {})),
-        // ...(silgi.scanModules.reduce((acc, m) => {
-        //   if (m.entryPath) {
-        //     const directory = getDirectory(m.entryPath)
-        //     // eslint-disable-next-line ts/ban-ts-comment
-        //     // @ts-ignore
-        //     acc[`${m.meta.name}/*`] = [`${relativeWithDot(tsconfigDir, directory)}/*`]
-        //   }
-        //   return acc
-        // }, {})),
-      }
-    },
-    include: [...include],
-    exclude: [...exclude]
-  });
-  tsConfig = defaultConfig;
-  if (isPresents(["hono"])) {
-    tsConfig = defu(defaultConfig, {
-      compilerOptions: {
-        jsx: "react-jsx",
-        jsxImportSource: "hono/jsx"
-      }
-    });
-  }
-  if (isPresents(["npm-package"])) {
-    tsConfig = defu(tsConfig, {
-      compilerOptions: {
-        target: "es2022",
-        lib: ["es2022", "webworker", "dom.iterable"],
-        moduleDetection: "force",
-        /* If NOT transpiling with TypeScript: */
-        module: "preserve",
-        paths: {},
-        resolveJsonModule: true,
-        allowJs: true,
-        /* Strictness */
-        strict: true,
-        noImplicitOverride: true,
-        noEmit: true,
-        allowSyntheticDefaultImports: true,
-        /* Base options: */
-        esModuleInterop: false,
-        forceConsistentCasingInFileNames: true,
-        isolatedModules: true,
-        verbatimModuleSyntax: true,
-        skipLibCheck: true
-      },
-      // include: ['src', 'test', './moduleTypes.d.ts'],
-      // exclude: ['dist', 'examples', 'playground', 'test/fixture'],
-      include: [...include],
-      exclude: [...exclude]
-    });
-  }
-  if (isPresents(["next"])) {
-    tsConfig = defu(tsConfig, {
-      compilerOptions: {
-        incremental: true,
-        plugins: [
-          { name: "next" }
-        ],
-        paths: {
-          "@/*": [
-            relativeWithDot(tsconfigDir, join(silgi.options.rootDir, "src", "*"))
-          ]
-        },
-        lib: [
-          "dom",
-          "dom.iterable",
-          "esnext"
-        ],
-        strictNullChecks: true
-      },
-      include: [
-        relativeWithDot(tsconfigDir, join(silgi.options.rootDir, "next-env.d.ts")),
-        relativeWithDot(tsconfigDir, join(silgi.options.rootDir, "**", "*.ts")),
-        relativeWithDot(tsconfigDir, join(silgi.options.rootDir, "**", "*.tsx")),
-        relativeWithDot(tsconfigDir, join(silgi.options.rootDir, ".next", "types", "**", "*.ts"))
-      ]
-    });
-  }
-  tsConfig.compilerOptions ||= {};
-  tsConfig.compilerOptions.paths ||= {};
-  tsConfig.include ||= [];
-  for (const alias in tsConfig.compilerOptions.paths) {
-    const paths = tsConfig.compilerOptions.paths[alias];
-    tsConfig.compilerOptions.paths[alias] = await Promise.all(
-      paths.map(async (path) => {
-        if (!isAbsolute(path)) {
-          return path;
-        }
-        const stats = await promises.stat(path).catch(
-          () => null
-          /* file does not exist */
-        );
-        return relativeWithDot(
-          tsconfigDir,
-          stats?.isFile() ? path.replace(/\b\.\w+$/g, "") : path
-        );
-      })
-    );
-  }
-  const references = [];
-  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
-    if (typeof id !== "string") {
-      return;
-    }
-    if (id === "./src" && silgi.options.preset === "npm-package") {
-      id = resolve(silgi.options.rootDir);
-    }
-    const pkg = await readPackageJSON(id, { url: silgi.options.rootDir }).catch(() => null);
-    references.push({ types: pkg?.name || id });
-  }));
-  const declarations = [];
-  await silgi.callHook("prepare:types", { references, declarations, tsConfig });
-  tsConfig.include = [...new Set(tsConfig.include.map((p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p))];
-  tsConfig.exclude = [...new Set(tsConfig.exclude.map((p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p))];
-  const _declarations = [
-    ...references.map((ref) => {
-      if ("path" in ref && isAbsolute(ref.path)) {
-        ref.path = relative(silgi.options.build.dir, ref.path);
-      }
-      return `/// <reference ${renderAttrs(ref)} />`;
-    }),
-    ...declarations,
-    "",
-    "export {}",
-    ""
-  ];
-  return {
-    declarations: _declarations,
-    tsConfig
-  };
-}
-
-export { silgiGenerateType as s };